diff --git a/ElectronNET.API/App.cs b/ElectronNET.API/App.cs index 471e3f7..2192143 100644 --- a/ElectronNET.API/App.cs +++ b/ElectronNET.API/App.cs @@ -10,6 +10,9 @@ namespace ElectronNET.API { public static class App { + /// + /// Communicate asynchronously from the main process to renderer processes. + /// public static IpcMain IpcMain { get; private set; } private static Socket _socket; @@ -45,41 +48,89 @@ namespace ElectronNET.API _socket.Emit("createNotification", JObject.FromObject(notificationOptions, _jsonSerializer)); } + /// + /// Try to close all windows. The before-quit event will be emitted first. If all + /// windows are successfully closed, the will-quit event will be emitted and by + /// default the application will terminate. This method guarantees that all + /// beforeunload and unload event handlers are correctly executed. It is possible + /// that a window cancels the quitting by returning false in the beforeunload event + /// handler. + /// public static void Quit() { _socket.Emit("appQuit"); } + /// + /// All windows will be closed immediately without asking user and + /// the before-quit and will-quit events will not be emitted. + /// + /// Exits immediately with exitCode. exitCode defaults to 0. public static void Exit(int exitCode = 0) { _socket.Emit("appExit", exitCode); } + /// + /// Relaunches the app when current instance exits. By default the new instance will + /// use the same working directory and command line arguments with current instance. + /// When args is specified, the args will be passed as command line arguments + /// instead. When execPath is specified, the execPath will be executed for relaunch + /// instead of current app. Note that this method does not quit the app when + /// executed, you have to call app.quit or app.exit after calling app.relaunch to + /// make the app restart. When app.relaunch is called for multiple times, multiple + /// instances will be started after current instance exited. + /// public static void Relaunch() { _socket.Emit("appRelaunch"); } + /// + /// Relaunches the app when current instance exits. By default the new instance will + /// use the same working directory and command line arguments with current instance. + /// When args is specified, the args will be passed as command line arguments + /// instead. When execPath is specified, the execPath will be executed for relaunch + /// instead of current app. Note that this method does not quit the app when + /// executed, you have to call app.quit or app.exit after calling app.relaunch to + /// make the app restart. When app.relaunch is called for multiple times, multiple + /// instances will be started after current instance exited. + /// + /// public static void Relaunch(RelaunchOptions relaunchOptions) { _socket.Emit("appRelaunch", JObject.FromObject(relaunchOptions, _jsonSerializer)); } + /// + /// On Linux, focuses on the first visible window. On macOS, makes the application + /// the active app.On Windows, focuses on the application's first window. + /// public static void Focus() { _socket.Emit("appFocus"); } + /// + /// Hides all application windows without minimizing them. + /// public static void Hide() { _socket.Emit("appHide"); } + /// + /// Shows application windows after they were hidden. Does not automatically focus them. + /// public static void Show() { _socket.Emit("appShow"); } + /// + /// The current application directory. + /// + /// public async static Task GetAppPathAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -95,6 +146,11 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// You can request the following paths by the name. + /// + /// + /// A path to a special directory or file associated with name. public async static Task GetPathAsync(PathName pathName) { var taskCompletionSource = new TaskCompletionSource(); @@ -112,6 +168,12 @@ namespace ElectronNET.API } // TODO: Fertig coden + /// + /// Fetches a path's associated icon. On Windows, there a 2 kinds of icons: On Linux + /// and macOS, icons depend on the application associated with file mime type. + /// + /// + /// //public async static Task GetFileIconAsync(string filePath) //{ // var taskCompletionSource = new TaskCompletionSource(); @@ -133,6 +195,14 @@ namespace ElectronNET.API //} // TODO: Fertig coden + + /// + /// Fetches a path's associated icon. On Windows, there a 2 kinds of icons: On Linux + /// and macOS, icons depend on the application associated with file mime type. + /// + /// + /// + /// //public async static Task GetFileIconAsync(string filePath, FileIconOptions fileIconOptions) //{ // var taskCompletionSource = new TaskCompletionSource(); @@ -150,11 +220,27 @@ namespace ElectronNET.API // return await taskCompletionSource.Task; //} + /// + /// Overrides the path to a special directory or file associated with name. If the + /// path specifies a directory that does not exist, the directory will be created by + /// this method.On failure an Error is thrown.You can only override paths of a + /// name defined in app.getPath. By default, web pages' cookies and caches will be + /// stored under the userData directory.If you want to change this location, you + /// have to override the userData path before the ready event of the app module is emitted. + /// + /// + /// public static void SetPath(string name, string path) { _socket.Emit("appSetPath", name, path); } + /// + /// The version of the loaded application. + /// If no version is found in the application’s package.json file, + /// the version of the current bundle or executable is returned. + /// + /// public async static Task GetVersionAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -170,6 +256,13 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Usually the name field of package.json is a short lowercased name, according to + /// the npm modules spec. You should usually also specify a productName field, which + /// is your application's full capitalized name, and which will be preferred over + /// name by Electron. + /// + /// The current application’s name, which is the name in the application’s package.json file. public async static Task GetNameAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -185,11 +278,21 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Overrides the current application's name. + /// + /// Application's name public static void SetName(string name) { _socket.Emit("appSetName", name); } + /// + /// The current application locale. + /// Note: When distributing your packaged app, you have to also ship the locales + /// folder.Note: On Windows you have to call it after the ready events gets emitted. + /// + /// public async static Task GetLocaleAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -205,16 +308,43 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Adds path to the recent documents list. This list is managed by the OS. On + /// Windows you can visit the list from the task bar, and on macOS you can visit it + /// from dock menu. + /// + /// public static void AddRecentDocument(string path) { _socket.Emit("appAddRecentDocument", path); } + /// + /// Clears the recent documents list. + /// public static void ClearRecentDocuments() { _socket.Emit("appClearRecentDocuments"); } + /// + /// This method sets the current executable as the default handler for a protocol + /// (aka URI scheme). It allows you to integrate your app deeper into the operating + /// system.Once registered, all links with your-protocol:// will be opened with the + /// current executable. The whole link, including protocol, will be passed to your + /// application as a parameter. On Windows you can provide optional parameters path, + /// the path to your executable, and args, an array of arguments to be passed to + /// your executable when it launches.Note: On macOS, you can only register + /// protocols that have been added to your app's info.plist, which can not be + /// modified at runtime.You can however change the file with a simple text editor + /// or script during build time. Please refer to Apple's documentation for details. + /// The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme + /// internally. + /// + /// The name of your protocol, without ://. + /// If you want your app to handle electron:// links, + /// call this method with electron as the parameter. + /// Whether the call succeeded. public async static Task SetAsDefaultProtocolClientAsync(string protocol) { var taskCompletionSource = new TaskCompletionSource(); @@ -230,6 +360,25 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method sets the current executable as the default handler for a protocol + /// (aka URI scheme). It allows you to integrate your app deeper into the operating + /// system.Once registered, all links with your-protocol:// will be opened with the + /// current executable. The whole link, including protocol, will be passed to your + /// application as a parameter. On Windows you can provide optional parameters path, + /// the path to your executable, and args, an array of arguments to be passed to + /// your executable when it launches.Note: On macOS, you can only register + /// protocols that have been added to your app's info.plist, which can not be + /// modified at runtime.You can however change the file with a simple text editor + /// or script during build time. Please refer to Apple's documentation for details. + /// The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme + /// internally. + /// + /// The name of your protocol, without ://. + /// If you want your app to handle electron:// links, + /// call this method with electron as the parameter. + /// Defaults to process.execPath + /// Whether the call succeeded. public async static Task SetAsDefaultProtocolClientAsync(string protocol, string path) { var taskCompletionSource = new TaskCompletionSource(); @@ -245,6 +394,26 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method sets the current executable as the default handler for a protocol + /// (aka URI scheme). It allows you to integrate your app deeper into the operating + /// system.Once registered, all links with your-protocol:// will be opened with the + /// current executable. The whole link, including protocol, will be passed to your + /// application as a parameter. On Windows you can provide optional parameters path, + /// the path to your executable, and args, an array of arguments to be passed to + /// your executable when it launches.Note: On macOS, you can only register + /// protocols that have been added to your app's info.plist, which can not be + /// modified at runtime.You can however change the file with a simple text editor + /// or script during build time. Please refer to Apple's documentation for details. + /// The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme + /// internally. + /// + /// The name of your protocol, without ://. + /// If you want your app to handle electron:// links, + /// call this method with electron as the parameter. + /// Defaults to process.execPath + /// Defaults to an empty array + /// Whether the call succeeded. public async static Task SetAsDefaultProtocolClientAsync(string protocol, string path, string[] args) { var taskCompletionSource = new TaskCompletionSource(); @@ -260,6 +429,12 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method checks if the current executable as the default handler for a + /// protocol(aka URI scheme). If so, it will remove the app as the default handler. + /// + /// The name of your protocol, without ://. + /// Whether the call succeeded. public async static Task RemoveAsDefaultProtocolClientAsync(string protocol) { var taskCompletionSource = new TaskCompletionSource(); @@ -275,6 +450,13 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method checks if the current executable as the default handler for a + /// protocol(aka URI scheme). If so, it will remove the app as the default handler. + /// + /// The name of your protocol, without ://. + /// Defaults to process.execPath. + /// Whether the call succeeded. public async static Task RemoveAsDefaultProtocolClientAsync(string protocol, string path) { var taskCompletionSource = new TaskCompletionSource(); @@ -290,6 +472,14 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method checks if the current executable as the default handler for a + /// protocol(aka URI scheme). If so, it will remove the app as the default handler. + /// + /// The name of your protocol, without ://. + /// Defaults to process.execPath. + /// Defaults to an empty array. + /// Whether the call succeeded. public async static Task RemoveAsDefaultProtocolClientAsync(string protocol, string path, string[] args) { var taskCompletionSource = new TaskCompletionSource(); @@ -305,6 +495,17 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method checks if the current executable is the default handler for a + /// protocol(aka URI scheme). If so, it will return true. Otherwise, it will return + /// false. Note: On macOS, you can use this method to check if the app has been + /// registered as the default protocol handler for a protocol.You can also verify + /// this by checking ~/Library/Preferences/com.apple.LaunchServices.plist on the + /// macOS machine.Please refer to Apple's documentation for details. The API uses + /// the Windows Registry and LSCopyDefaultHandlerForURLScheme internally. + /// + /// The name of your protocol, without ://. + /// Returns Boolean public async static Task IsDefaultProtocolClientAsync(string protocol) { var taskCompletionSource = new TaskCompletionSource(); @@ -320,6 +521,18 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method checks if the current executable is the default handler for a + /// protocol(aka URI scheme). If so, it will return true. Otherwise, it will return + /// false. Note: On macOS, you can use this method to check if the app has been + /// registered as the default protocol handler for a protocol.You can also verify + /// this by checking ~/Library/Preferences/com.apple.LaunchServices.plist on the + /// macOS machine.Please refer to Apple's documentation for details. The API uses + /// the Windows Registry and LSCopyDefaultHandlerForURLScheme internally. + /// + /// The name of your protocol, without ://. + /// Defaults to process.execPath. + /// Returns Boolean public async static Task IsDefaultProtocolClientAsync(string protocol, string path) { var taskCompletionSource = new TaskCompletionSource(); @@ -335,6 +548,19 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// This method checks if the current executable is the default handler for a + /// protocol(aka URI scheme). If so, it will return true. Otherwise, it will return + /// false. Note: On macOS, you can use this method to check if the app has been + /// registered as the default protocol handler for a protocol.You can also verify + /// this by checking ~/Library/Preferences/com.apple.LaunchServices.plist on the + /// macOS machine.Please refer to Apple's documentation for details. The API uses + /// the Windows Registry and LSCopyDefaultHandlerForURLScheme internally. + /// + /// The name of your protocol, without ://. + /// Defaults to process.execPath. + /// Defaults to an empty array. + /// Returns Boolean public async static Task IsDefaultProtocolClientAsync(string protocol, string path, string[] args) { var taskCompletionSource = new TaskCompletionSource(); @@ -350,6 +576,13 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Adds tasks to the Tasks category of the JumpList on Windows. tasks is an array + /// of Task objects.Note: If you'd like to customize the Jump List even more use + /// app.setJumpList(categories) instead. + /// + /// Array of Task objects. + /// Whether the call succeeded. public async static Task SetUserTasksAsync(UserTask[] userTasks) { var taskCompletionSource = new TaskCompletionSource(); @@ -365,6 +598,10 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Jump List settings for the application. + /// + /// public async static Task GetJumpListSettingsAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -380,11 +617,50 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Sets or removes a custom Jump List for the application, and returns one of the + /// following strings: If categories is null the previously set custom Jump List(if + /// any) will be replaced by the standard Jump List for the app(managed by + /// Windows). Note: If a JumpListCategory object has neither the type nor the name + /// property set then its type is assumed to be tasks.If the name property is set + /// but the type property is omitted then the type is assumed to be custom. Note: + /// Users can remove items from custom categories, and Windows will not allow a + /// removed item to be added back into a custom category until after the next + /// successful call to app.setJumpList(categories). Any attempt to re-add a removed + /// item to a custom category earlier than that will result in the entire custom + /// category being omitted from the Jump List. The list of removed items can be + /// obtained using app.getJumpListSettings(). + /// + /// public static void SetJumpList(JumpListCategory[] jumpListCategories) { _socket.Emit("appSetJumpList", JObject.FromObject(jumpListCategories, _jsonSerializer)); } + /// + /// This method makes your application a Single Instance Application - instead of + /// allowing multiple instances of your app to run, this will ensure that only a + /// single instance of your app is running, and other instances signal this instance + /// and exit.callback will be called by the first instance with callback(argv, + /// workingDirectory) when a second instance has been executed.argv is an Array of + /// the second instance's command line arguments, and workingDirectory is its + /// current working directory.Usually applications respond to this by making their + /// primary window focused and non-minimized.The callback is guaranteed to be + /// executed after the ready event of app gets emitted.This method returns false if + /// your process is the primary instance of the application and your app should + /// continue loading.And returns true if your process has sent its parameters to + /// another instance, and you should immediately quit.On macOS the system enforces + /// single instance automatically when users try to open a second instance of your + /// app in Finder, and the open-file and open-url events will be emitted for that. + /// However when users start your app in command line the system's single instance + /// mechanism will be bypassed and you have to use this method to ensure single + /// instance. + /// + /// Lambda with an array of the second instance’s command line arguments. + /// The second parameter is the working directory path. + /// This method returns false if your process is the primary instance of + /// the application and your app should continue loading. And returns true if your + /// process has sent its parameters to another instance, and you should immediately quit. public async static Task MakeSingleInstanceAsync(Action newInstanceOpened) { var taskCompletionSource = new TaskCompletionSource(); @@ -410,21 +686,42 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Releases all locks that were created by makeSingleInstance. This will allow + /// multiple instances of the application to once again run side by side. + /// public static void ReleaseSingleInstance() { _socket.Emit("appReleaseSingleInstance"); } + /// + /// Creates an NSUserActivity and sets it as the current activity. The activity is + /// eligible for Handoff to another device afterward. + /// + /// Uniquely identifies the activity. Maps to NSUserActivity.activityType. + /// App-specific state to store for use by another device. public static void SetUserActivity(string type, object userInfo) { _socket.Emit("appSetUserActivity", type, userInfo); } + /// + /// Creates an NSUserActivity and sets it as the current activity. The activity is + /// eligible for Handoff to another device afterward. + /// + /// Uniquely identifies the activity. Maps to NSUserActivity.activityType. + /// App-specific state to store for use by another device. + /// The webpage to load in a browser if no suitable app is installed on the resuming device. The scheme must be http or https. public static void SetUserActivity(string type, object userInfo, string webpageURL) { _socket.Emit("appSetUserActivity", type, userInfo, webpageURL); } + /// + /// The type of the currently running activity. + /// + /// public async static Task GetCurrentActivityTypeAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -440,11 +737,22 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Changes the Application User Model ID to id. + /// + /// public static void SetAppUserModelId(string id) { _socket.Emit("appSetAppUserModelId", id); } + /// + /// Imports the certificate in pkcs12 format into the platform certificate store. + /// callback is called with the result of import operation, a value of 0 indicates + /// success while any other value indicates failure according to chromium net_error_list. + /// + /// + /// Result of import. Value of 0 indicates success. public async static Task ImportCertificateAsync(ImportCertificateOptions options) { var taskCompletionSource = new TaskCompletionSource(); @@ -460,6 +768,10 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Memory and cpu usage statistics of all the processes associated with the app. + /// + /// public async static Task GetAppMetricsAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -477,6 +789,10 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// The Graphics Feature Status from chrome://gpu/. + /// + /// public async static Task GetGpuFeatureStatusAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -494,6 +810,14 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Sets the counter badge for current app. Setting the count to 0 will hide the + /// badge. On macOS it shows on the dock icon. On Linux it only works for Unity + /// launcher, Note: Unity launcher requires the existence of a.desktop file to + /// work, for more information please read Desktop Environment Integration. + /// + /// + /// Whether the call succeeded. public async static Task SetBadgeCountAsync(int count) { var taskCompletionSource = new TaskCompletionSource(); @@ -509,6 +833,10 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// The current value displayed in the counter badge. + /// + /// public async static Task GetBadgeCountAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -524,6 +852,10 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Whether the current desktop environment is Unity launcher. + /// + /// public async static Task IsUnityRunningAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -539,6 +871,12 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// If you provided path and args options to app.setLoginItemSettings then you need + /// to pass the same arguments here for openAtLogin to be set correctly. Note: This + /// API has no effect on MAS builds. + /// + /// public async static Task GetLoginItemSettingsAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -554,6 +892,13 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// If you provided path and args options to app.setLoginItemSettings then you need + /// to pass the same arguments here for openAtLogin to be set correctly. Note: This + /// API has no effect on MAS builds. + /// + /// + /// public async static Task GetLoginItemSettingsAsync(LoginItemSettingsOptions options) { var taskCompletionSource = new TaskCompletionSource(); @@ -569,11 +914,23 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Set the app's login item settings. To work with Electron's autoUpdater on + /// Windows, which uses Squirrel, you'll want to set the launch path to Update.exe, + /// and pass arguments that specify your application name. + /// + /// public static void SetLoginItemSettings(LoginSettings loginSettings) { _socket.Emit("appSetLoginItemSettings", JObject.FromObject(loginSettings, _jsonSerializer)); } + /// + /// This API will return true if the use of assistive technologies, + /// such as screen readers, has been detected. + /// See https://www.chromium.org/developers/design-documents/accessibility for more details. + /// + /// true if Chrome’s accessibility support is enabled, false otherwise. public async static Task IsAccessibilitySupportEnabledAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -589,31 +946,65 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Set the about panel options. This will override the values defined in the app's + /// .plist file. See the Apple docs for more details. + /// + /// public static void SetAboutPanelOptions(AboutPanelOptions options) { _socket.Emit("appSetAboutPanelOptions", JObject.FromObject(options, _jsonSerializer)); } + /// + /// Append a switch (with optional value) to Chromium's command line. Note: This + /// will not affect process.argv, and is mainly used by developers to control some + /// low-level Chromium behaviors. + /// + /// A command-line switch. public static void CommandLineAppendSwitch(string theSwtich) { _socket.Emit("appCommandLineAppendSwitch", theSwtich); } + /// + /// Append a switch (with optional value) to Chromium's command line. Note: This + /// will not affect process.argv, and is mainly used by developers to control some + /// low-level Chromium behaviors. + /// + /// A command-line switch. + /// A value for the given switch. public static void CommandLineAppendSwitch(string theSwtich, string value) { _socket.Emit("appCommandLineAppendSwitch", theSwtich, value); } + /// + /// Append an argument to Chromium's command line. The argument will be quoted + /// correctly.Note: This will not affect process.argv. + /// + /// The argument to append to the command line. public static void CommandLineAppendArgument(string value) { _socket.Emit("appCommandLineAppendArgument", value); } + /// + /// Enables mixed sandbox mode on the app. This method can only be called before app is ready. + /// public static void EnableMixedSandbox() { _socket.Emit("appEnableMixedSandbox"); } + /// + /// When critical is passed, the dock icon will bounce until either the application + /// becomes active or the request is canceled.When informational is passed, the + /// dock icon will bounce for one second.However, the request remains active until + /// either the application becomes active or the request is canceled. + /// + /// + /// public async static Task DockBounceAsync(DockBounceType type) { var taskCompletionSource = new TaskCompletionSource(); @@ -629,21 +1020,37 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Cancel the bounce of id. + /// + /// public static void DockCancelBounce(int id) { _socket.Emit("appDockCancelBounce", id); } + /// + /// Bounces the Downloads stack if the filePath is inside the Downloads folder. + /// + /// public static void DockDownloadFinished(string filePath) { _socket.Emit("appDockDownloadFinished", filePath); } + /// + /// Sets the string to be displayed in the dock’s badging area. + /// + /// public static void DockSetBadge(string text) { _socket.Emit("appDockSetBadge", text); } + /// + /// Gets the string to be displayed in the dock’s badging area. + /// + /// public async static Task DockGetBadgeAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -659,16 +1066,27 @@ namespace ElectronNET.API return await taskCompletionSource.Task; } + /// + /// Hides the dock icon. + /// public static void DockHide() { _socket.Emit("appDockHide"); } + /// + /// Shows the dock icon. + /// public static void DockShow() { _socket.Emit("appDockShow"); } + /// + /// Whether the dock icon is visible. The app.dock.show() call is asynchronous + /// so this method might not return true immediately after that call. + /// + /// public async static Task DockIsVisibleAsync() { var taskCompletionSource = new TaskCompletionSource(); @@ -685,16 +1103,27 @@ namespace ElectronNET.API } // TODO: Menu lösung muss gemacht werden und imeplementiert + /// + /// Sets the application's dock menu. + /// public static void DockSetMenu() { _socket.Emit("appDockSetMenu"); } + /// + /// Sets the image associated with this dock icon. + /// + /// public static void DockSetIcon(string image) { _socket.Emit("appDockSetIcon", image); } + /// + /// Sets the image associated with this dock icon. + /// + /// //public static void DockSetIcon(NativeImage image) //{ // _socket.Emit("appDockSetIcon", JObject.FromObject(image, _jsonSerializer)); diff --git a/ElectronNET.API/Entities/JumpListCategory.cs b/ElectronNET.API/Entities/JumpListCategory.cs index abf8c5c..e7ca486 100644 --- a/ElectronNET.API/Entities/JumpListCategory.cs +++ b/ElectronNET.API/Entities/JumpListCategory.cs @@ -4,8 +4,19 @@ namespace ElectronNET.API { public class JumpListCategory { + /// + /// Must be set if type is custom, otherwise it should be omitted. + /// public string Name { get; set; } = string.Empty; + + /// + /// Array of objects if type is tasks or custom, otherwise it should be omitted. + /// public JumpListItem[] Items { get; set; } = new JumpListItem[0]; + + /// + /// One of the following: "tasks" | "frequent" | "recent" | "custom" + /// public string Type { get; set; } = "tasks"; } } diff --git a/ElectronNET.API/Entities/JumpListItem.cs b/ElectronNET.API/Entities/JumpListItem.cs index f38562b..8d1ac63 100644 --- a/ElectronNET.API/Entities/JumpListItem.cs +++ b/ElectronNET.API/Entities/JumpListItem.cs @@ -2,13 +2,50 @@ { public class JumpListItem { + /// + /// The command line arguments when program is executed. Should only be set if type is task. + /// public string Args { get; set; } = string.Empty; + + /// + /// Description of the task (displayed in a tooltip). Should only be set if type is task. + /// public string Description { get; set; } = string.Empty; + + /// + /// The index of the icon in the resource file. If a resource file contains multiple + /// icons this value can be used to specify the zero-based index of the icon that + /// should be displayed for this task.If a resource file contains only one icon, + /// this property should be set to zero. + /// public int IconIndex { get; set; } = 0; + + /// + /// The absolute path to an icon to be displayed in a Jump List, which can be an + /// arbitrary resource file that contains an icon(e.g. .ico, .exe, .dll). You can + /// usually specify process.execPath to show the program icon. + /// public string IconPath { get; set; } = string.Empty; + + /// + /// Path of the file to open, should only be set if type is file. + /// public string Path { get; set; } = string.Empty; + + /// + /// Path of the program to execute, usually you should specify process.execPath + /// which opens the current program.Should only be set if type is task. + /// public string Program { get; set; } = string.Empty; + + /// + /// The text to be displayed for the item in the Jump List. Should only be set if type is task. + /// public string Title { get; set; } = string.Empty; + + /// + /// One of the following: "task" | "separator" | "file" + /// public string Type {get; set; } = string.Empty; } } diff --git a/ElectronNET.API/Entities/JumpListSettings.cs b/ElectronNET.API/Entities/JumpListSettings.cs index d4f3bc0..b7964cd 100644 --- a/ElectronNET.API/Entities/JumpListSettings.cs +++ b/ElectronNET.API/Entities/JumpListSettings.cs @@ -2,8 +2,14 @@ { public class JumpListSettings { + /// + /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the MSDN docs). + /// public int MinItems { get; set; } = 0; + /// + /// Array of JumpListItem objects that correspond to items that the user has explicitly removed from custom categories in the Jump List. These items must not be re-added to the Jump List in the next call to app.setJumpList(), Windows will not display any custom category that contains any of the removed items. + /// public JumpListItem[] RemovedItems { get; set; } = new JumpListItem[0]; } } diff --git a/ElectronNET.API/Entities/PathName.cs b/ElectronNET.API/Entities/PathName.cs index 48173d8..0435b4c 100644 --- a/ElectronNET.API/Entities/PathName.cs +++ b/ElectronNET.API/Entities/PathName.cs @@ -1,24 +1,76 @@ -using System; -using System.Collections.Generic; -using System.Text; - -namespace ElectronNET.API.Entities +namespace ElectronNET.API.Entities { public enum PathName { + /// + /// User’s home directory. + /// home, + + /// + /// Per-user application data directory. + /// appData, + + /// + /// The directory for storing your app’s configuration files, + /// which by default it is the appData directory appended with your app’s name. + /// userData, + + /// + /// Temporary directory. + /// temp, + + /// + /// The current executable file. + /// exe, + + /// + /// The libchromiumcontent library. + /// module, + + /// + /// The current user’s Desktop directory. + /// desktop, + + /// + /// Directory for a user’s “My Documents”. + /// documents, + + /// + /// Directory for a user’s downloads. + /// downloads, + + /// + /// Directory for a user’s music. + /// music, + + /// + /// Directory for a user’s pictures. + /// pictures, + + /// + /// Directory for a user’s videos. + /// videos, + + /// + /// + /// logs, + + /// + /// Full path to the system version of the Pepper Flash plugin. + /// pepperFlashSystemPlugin } } diff --git a/ElectronNET.API/IpcMain.cs b/ElectronNET.API/IpcMain.cs index db3bdfc..cc6fa49 100644 --- a/ElectronNET.API/IpcMain.cs +++ b/ElectronNET.API/IpcMain.cs @@ -3,9 +3,9 @@ using Quobject.SocketIoClientDotNet.Client; namespace ElectronNET.API { - // - // Summary: - // Communicate asynchronously from the main process to renderer processes. + /// + /// Communicate asynchronously from the main process to renderer processes. + /// public class IpcMain { private Socket _socket; @@ -27,50 +27,35 @@ namespace ElectronNET.API _socket.On(channel, listener); } - // Summary: - // Adds a one time listener method for the event. This listener is invoked only - // the next time a message is sent to channel, after which it is removed. - // - // Parameters: - // channel: - // Channelname. - // - // listener: - // Callback Method. - // + /// + /// Adds a one time listener method for the event. This listener is invoked only + /// the next time a message is sent to channel, after which it is removed. + /// + /// Channelname. + /// Callback Method. public void Once(string channel, Action listener) { _socket.Emit("registerOnceIpcMainChannel", channel); _socket.On(channel, listener); } - // - // Summary: - // Removes listeners of the specified channel. - // - // Parameters: - // channel: - // Channelname. - // + /// + /// Removes listeners of the specified channel. + /// + /// Channelname. public void RemoveAllListeners(string channel) { _socket.Emit("removeAllListenersIpcMainChannel", channel); } - // - // Summary: - // Send a message to the renderer process asynchronously via channel, you can also send - // arbitrary arguments. Arguments will be serialized in JSON internally and hence - // no functions or prototype chain will be included. The renderer process handles it by - // listening for channel with ipcRenderer module. - // - // Parameters: - // channel: - // Channelname. - // - // data: - // Arguments data. - // + /// + /// Send a message to the renderer process asynchronously via channel, you can also send + /// arbitrary arguments. Arguments will be serialized in JSON internally and hence + /// no functions or prototype chain will be included. The renderer process handles it by + /// listening for channel with ipcRenderer module. + /// + /// Channelname. + /// Arguments data. public void Send(string channel, params object[] data) { _socket.Emit("sendToIpcRenderer", channel, data); diff --git a/ElectronNET.WebApp/Controllers/HomeController.cs b/ElectronNET.WebApp/Controllers/HomeController.cs index 1de15fa..fcc5116 100644 --- a/ElectronNET.WebApp/Controllers/HomeController.cs +++ b/ElectronNET.WebApp/Controllers/HomeController.cs @@ -29,7 +29,9 @@ namespace ElectronNET.WebApp.Controllers //var imagePath = Path.Combine(result, "Electron.png"); App.IpcMain.Send("GetPathComplete", result); - var image = await App.GetFileIconAsync(result); + + //var image = await App.GetFileIconAsync(result); + }); return View();