/// <inheritdoc />
public async Task SaveProjectAsync()
{
if (string.IsNullOrWhiteSpace(CurrentProject.ProjectPath))
{
var saveDialogOptions = new SaveDialogOptions
{
Title = Translator.Translate("Please choose where to save your Project File"),
Filters = new[]
{
new FileFilter
{
Extensions = new[] { "json" }, Name = Translator.Translate("Project File")
}
}
};
var saveFilePath = await ElectronHelper.ShowSaveDialogAsync(ElectronHelper.GetBrowserWindow(), saveDialogOptions);
if (string.IsNullOrWhiteSpace(saveFilePath))
{
return;
}
CurrentProject.ProjectPath = saveFilePath;
}
await CurrentProject.SaveAsync();
}
public static async Task SaveFileAsAsync()
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new SaveDialogOptions
{
Title = "Save As..."
};
var filePath = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
var task = new Task(() =>
{
try
{
ApplicationState.Instance.FileHandlerInstance.SaveFile(CurrentFilePath, filePath);
}
catch (InvalidOperationException e)
{
Electron.Dialog.ShowErrorBox("File Error", "File couldn't be saved.");
Console.WriteLine(e.StackTrace);
}
});
task.Start();
await task;
}
public IActionResult Index()
{
if (HybridSupport.IsElectronActive)
{
//save file
Electron.IpcMain.On("saveFile", async(args) =>
{
string content = args.ToString();
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new SaveDialogOptions
{
Title = "Save HTML file",
Filters = new FileFilter[]
{
new FileFilter {
Name = "HTML", Extensions = new string[] { "html", "htm" }
}
}
};
string result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
if (result.Count() != 0)
{
FileOperation.saveFile(content, result);
}
});
}
return(View());
}
public IActionResult Index()
{
if (!HybridSupport.IsElectronActive || saveAdded)
{
return(Ok());
}
Electron.IpcMain.On("save-dialog", async(args) =>
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new SaveDialogOptions
{
Title = "Save contact as JSON",
Filters = new FileFilter[]
{
new FileFilter {
Name = "JSON", Extensions = new string[] { "json" }
}
}
};
var result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
Electron.IpcMain.Send(mainWindow, "save-dialog-reply", result);
});
saveAdded = true;
return(Ok());
}
public IActionResult Index()
{
if (HybridSupport.IsElectronActive)
{
Electron.IpcMain.On("print-pdf", async(args) =>
{
BrowserWindow mainWindow = Electron.WindowManager.BrowserWindows.First();
var saveOptions = new SaveDialogOptions
{
Title = "Save an PDF-File",
DefaultPath = await Electron.App.GetPathAsync(PathName.documents),
Filters = new FileFilter[]
{
new FileFilter {
Name = "PDF", Extensions = new string[] { "pdf" }
}
}
};
var path = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, saveOptions);
if (await mainWindow.WebContents.PrintToPDFAsync(path))
{
await Electron.Shell.OpenExternalAsync("file://" + path);
}
else
{
Electron.Dialog.ShowErrorBox("Error", "Failed to create pdf file.");
}
});
}
return(View());
}
public async Task ExportConfig()
{
var saveoptions = new SaveDialogOptions()
{
Title = "导出配置",
Message = "请选择文件保存位置",
Filters = new FileFilter[]
{
new FileFilter()
{
Extensions = new string[] { "json" },
Name = "JSON配置文件"
}
},
DefaultPath = "maps.json"
};
var path = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, saveoptions);
if (!string.IsNullOrWhiteSpace(path))
{
try
{
File.Copy(Path.Combine(Directory.GetCurrentDirectory(), "maps.json"),
path);
}
catch (Exception)
{
}
}
}
public IActionResult Index()
{
if (HybridSupport.IsElectronActive)
{
Electron.IpcMain.On("select-directory", async(args) => {
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new OpenDialogOptions
{
Properties = new OpenDialogProperty[] {
OpenDialogProperty.openFile,
//OpenDialogProperty.openDirectory
}
};
string[] files = await Electron.Dialog.ShowOpenDialogAsync(mainWindow, options);
Electron.IpcMain.Send(mainWindow, "select-directory-reply", files);
});
Electron.IpcMain.On("error-dialog", (args) =>
{
Electron.Dialog.ShowErrorBox("An Error Message", "Demonstrating an error message.");
});
Electron.IpcMain.On("information-dialog", async(args) =>
{
var options = new MessageBoxOptions("This is an information dialog. Isn't it nice?")
{
Type = MessageBoxType.info,
Title = "Information",
Buttons = new string[] { "Yes", "No" }
};
var result = await Electron.Dialog.ShowMessageBoxAsync(options);
var mainWindow = Electron.WindowManager.BrowserWindows.First();
Electron.IpcMain.Send(mainWindow, "information-dialog-reply", result.Response);
});
Electron.IpcMain.On("save-dialog", async(args) =>
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new SaveDialogOptions
{
Title = "Save an Image",
Filters = new FileFilter[]
{
new FileFilter {
Name = "Images", Extensions = new string[] { "jpg", "png", "gif" }
}
}
};
var result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
Electron.IpcMain.Send(mainWindow, "save-dialog-reply", result);
});
}
return(View());
}
private async void SaveDialog(string ipc)
{
var options = new SaveDialogOptions
{
Title = "Save an Image",
Filters = new FileFilter[]
{
new FileFilter {
Name = "Images", Extensions = new string[] { "jpg", "png", "gif" }
}
}
};
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
Reply(ipc, result);
}
private void SaveConfiguration()
{
Task.Run((() =>
{
var options = new SaveDialogOptions()
{
Message = "Save the configuration file",
Title = "Save",
Filters = new[]
{
new FileFilter()
{
Name = "MinZeBox Configuration",
Extensions = new[] { "mbox" }
}
},
DefaultPath = "~/configuration.mbox"
};
return(Electron.Dialog.ShowSaveDialogAsync(MainWindow, options));
})).ContinueWith(task => Console.WriteLine(task.Result));
}
private static void demo_Window_ShowSaveDialog()
{
SaveDialogOptions opts = default;
opts = new SaveDialogOptions();
opts.SaveLabel = "Note: won't actually write to specified file path";
opts.Filters = new Dictionary <string, string[]>(2);
opts.Filters["All"] = new[] { "*" };
opts.Filters["Dummy Filter"] = new[] { "dummy", "demo" };
logLn("Showing File-Save dialog...");
vsc.Window.ShowSaveDialog(opts)((string filepath) => {
if ((null == filepath))
{
vsc.Window.ShowWarningMessage(logLn("Cancelled File-Save dialog, chicken?"), null);
}
else
{
vsc.Window.ShowInformationMessage(logLn(strFmt("Selected file path `{0}`, excellent!", filepath)), null);
}
});
}
private void CreateMenu()
{
bool isMac = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
MenuItem[] menu = null;
MenuItem[] appMenu = new MenuItem[]
{
new MenuItem {
Role = MenuRole.about
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Role = MenuRole.services
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Role = MenuRole.hide
},
new MenuItem {
Role = MenuRole.hideothers
},
new MenuItem {
Role = MenuRole.unhide
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Role = MenuRole.quit
}
};
MenuItem[] fileMenu = new MenuItem[]
{
new MenuItem {
Label = "Save As...", Type = MenuType.normal, Click = async() => {
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new SaveDialogOptions()
{
Filters = new FileFilter[] { new FileFilter {
Name = "CSV Files", Extensions = new string[] { "csv" }
} }
};
string result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
if (!string.IsNullOrEmpty(result))
{
string url = $"http://localhost:{BridgeSettings.WebPort}/SaveAs?path={result}";
mainWindow.LoadURL(url);
}
}
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Role = isMac ? MenuRole.close : MenuRole.quit
}
};
MenuItem[] viewMenu = new MenuItem[]
{
new MenuItem {
Role = MenuRole.reload
},
new MenuItem {
Role = MenuRole.forcereload
},
new MenuItem {
Role = MenuRole.toggledevtools
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Role = MenuRole.resetzoom
},
new MenuItem {
Role = MenuRole.zoomin
},
new MenuItem {
Role = MenuRole.zoomout
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Role = MenuRole.togglefullscreen
}
};
if (isMac)
{
menu = new MenuItem[]
{
new MenuItem {
Label = "Electron", Type = MenuType.submenu, Submenu = appMenu
},
new MenuItem {
Label = "File", Type = MenuType.submenu, Submenu = fileMenu
},
new MenuItem {
Label = "View", Type = MenuType.submenu, Submenu = viewMenu
}
};
}
else
{
menu = new MenuItem[]
{
new MenuItem {
Label = "File", Type = MenuType.submenu, Submenu = fileMenu
},
new MenuItem {
Label = "View", Type = MenuType.submenu, Submenu = viewMenu
}
};
}
Electron.Menu.SetApplicationMenu(menu);
}
/// <summary>
/// Default entry into managed code.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <object> Invoke(object input)
{
if (console == null)
{
console = await WebSharpJs.NodeJS.Console.Instance();
}
try
{
// Since we are executing from the Renderer process we have to use
// dialog remote process.
dialog = await Dialog.Instance();
var page = new HtmlPage();
document = await page.GetDocument();
// Get the HtmlElement with the id of "openFile"
var openFile = await document.GetElementById("openFile");
// Attach a "click" event handler to the openFile HtmlElement
await openFile.AttachEvent("click", new EventHandler(async(sender, evt) =>
{
// Create an OpenDialogOptions reference with custom FileFilters
var openOptions = new OpenDialogOptions()
{
Filters = new FileFilter[]
{
new FileFilter()
{
Name = "text", Extensions = new string[] { "txt" }
},
new FileFilter()
{
Name = "All Files", Extensions = new string[] { "*" }
}
}
};
// Now show the open dialog passing in the options created previously
// and a call back function when a file is selected.
// If a call back function is not specified then the ShowOpenDialog function
// will return an array of the selected file(s) or an empty array if no
// files are selected.
await dialog.ShowOpenDialog(
openOptions,
openFileCallback
);
}
));
// Get the HtmlElement with the id of "saveFile"
var saveFile = await document.GetElementById("saveFile");
// Attach a "click" event handler to the saveFile HtmlElement
await saveFile.AttachEvent("click", new EventHandler(async(sender, evt) =>
{
// Create an OpenDialogOptions reference with custom FileFilters
var saveOptions = new SaveDialogOptions()
{
Filters = new FileFilter[]
{
new FileFilter()
{
Name = "text", Extensions = new string[] { "txt" }
},
new FileFilter()
{
Name = "All Files", Extensions = new string[] { "*" }
}
}
};
// Now show the save dialog passing in the options created previously
// and a call back function to be called when the save button is clicked.
// If a call back function is not specified then the ShowSaveDialog function
// will return a string or an empty string if no file was specified.
await dialog.ShowSaveDialog(
saveOptions,
saveFileCallback
);
}
));
}
catch (Exception exc) { await dialog.ShowErrorBox("There was an error: ", exc.Message); }
return(null);
}
public IActionResult Read(string path)
{
if (!System.IO.File.Exists(path))
{
return(NotFound("The book path was not found."));
}
var book = EpubReader.Library.EpubReader.ReadBook(path);
var bookFromLibrary = _bookRepository.GetAll().SingleOrDefault(b => b.Path.Equals(path, StringComparison.InvariantCultureIgnoreCase));
if (bookFromLibrary != null)
{
bookFromLibrary.LastOpened = DateTime.Now;
_bookRepository.Update(bookFromLibrary);
}
var bookModel = new Models.book
{
Title = book.Title,
Author = book.Author,
FileName = path
};
List <Models.Chapter> chapters = new List <Models.Chapter>();
Func <EpubChapter, Chapter> funcConvert = null;
funcConvert = new Func <EpubChapter, Chapter>((epChapter) =>
{
Chapter chapter = new Chapter {
FileName = epChapter.ContentFileName, Title = epChapter.Title, Book = bookModel
};
if (epChapter.SubChapters != null && epChapter.SubChapters.Any())
{
foreach (var epSubChapter in epChapter.SubChapters)
{
chapter.Chapters.Add(funcConvert(epSubChapter));
}
}
return(chapter);
});
foreach (var epChapter in book.Chapters)
{
chapters.Add(funcConvert(epChapter));
}
bookModel.Chapters = chapters;
if (HybridSupport.IsElectronActive)
{
Electron.IpcMain.On("export-book", async(args) =>
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var options = new SaveDialogOptions
{
Filters = new FileFilter[] {
new FileFilter {
Extensions = new string[] { "*.txt" }, Name = "Archivos de texto plano(*.txt)"
}
},
Title = "Exportar libro a texto plano"
};
string file = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);
if (!String.IsNullOrWhiteSpace(file))
{
try
{
var bookToExport = EpubReader.Library.EpubReader.ReadBook(path);
var regex = new Regex(@"<[^>]*>", RegexOptions.IgnoreCase);
List <EpubChapter> allChapters = bookToExport.GetAllChapters();
string wholeBook = String.Join(Environment.NewLine, allChapters.Select(ch =>
{
return(regex.Replace(ch.HtmlContent, String.Empty));
}).ToArray());
System.IO.File.WriteAllText(file, wholeBook, Encoding.UTF8);
Electron.IpcMain.Send(mainWindow, "export-book-reply", true);
}
catch (Exception ex)
{
Electron.IpcMain.Send(mainWindow, "export-file-reply", ex.Message);
}
}
});
}
return(View(bookModel));
}
private async Task ExportExcelAction(object args)
{
var query = await _context.Soci
.Include(x => x.Tipologia)
.Include(x => x.DatiAuto)
.AsNoTracking().ToListAsync();
_logger.LogInformation("Esporto soci");
BrowserWindow mainWindow = Electron.WindowManager.BrowserWindows.First();
var saveOptions = new SaveDialogOptions
{
Title = "Save a Excel File",
DefaultPath = await Electron.App.GetPathAsync(PathName.Documents),
Filters = new FileFilter[]
{
new FileFilter {
Name = "xlsx", Extensions = new string[] { "xlsx" }
}
}
};
var path = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, saveOptions);
if (string.IsNullOrEmpty(path))
{
return;
}
try
{
using (var p = new ExcelPackage())
{
var ws = p.Workbook.Worksheets.Add("Soci Filarmonica");
int riga = 1;
//creo intestazione
ws.Cells[riga, 1].Value = "Numero socio";
ws.Cells[riga, 2].Value = "Tipologia socio";
ws.Cells[riga, 3].Value = "Nome";
ws.Cells[riga, 4].Value = "Cognome";
ws.Cells[riga, 5].Value = "Indirizzo";
ws.Cells[riga, 6].Value = "Cap";
ws.Cells[riga, 7].Value = "Città";
ws.Cells[riga, 8].Value = "Telefono";
ws.Cells[riga, 9].Value = "Telefono 2";
ws.Cells[riga, 10].Value = "Email";
ws.Cells[riga, 11].Value = "Email 2";
ws.Cells[riga, 12].Value = "Codice fiscale";
ws.Cells[riga, 13].Value = "Numero tessera ambima";
ws.Cells[riga, 14].Value = "Data di nascita";
ws.Cells[riga, 15].Value = "Luogo di nascita";
ws.Cells[riga, 16].Value = "Tipo auto";
ws.Cells[riga, 17].Value = "Carburante";
ws.Cells[riga, 18].Value = "Descrizione macchina";
ws.Cells[riga, 19].Value = "Targa macchina";
//metto i dati
riga++;
foreach (var item in query)
{
ws.Cells[riga, 1].Value = item.NumeroSocio;
ws.Cells[riga, 2].Value = item.Tipologia?.Descrizione;
ws.Cells[riga, 3].Value = item.Nome;
ws.Cells[riga, 4].Value = item.Cognome;
ws.Cells[riga, 5].Value = item.Indirizzo;
ws.Cells[riga, 6].Value = item.Cap;
ws.Cells[riga, 7].Value = item.Citta;
ws.Cells[riga, 8].Value = item.Telefono;
ws.Cells[riga, 9].Value = item.Telefono2;
ws.Cells[riga, 10].Value = item.Email;
ws.Cells[riga, 11].Value = item.Email2;
ws.Cells[riga, 12].Value = item.CodiceFiscale;
ws.Cells[riga, 13].Value = item.NumeroTesseraAmbima;
ws.Cells[riga, 14].Value = item.DataNascita;
ws.Cells[riga, 15].Value = item.LuogoNascita;
ws.Cells[riga, 16].Value = item.DatiAuto?.TipoAuto;
ws.Cells[riga, 17].Value = item.DatiAuto?.Carburante;
ws.Cells[riga, 18].Value = item.DescrizioneMacchina;
ws.Cells[riga, 19].Value = item.TargaMacchina;
riga++;
}
p.SaveAs(new FileInfo(path));
await Electron.Dialog.ShowMessageBoxAsync(mainWindow, "Salvato!");
}
}
catch (Exception ex)
{
string message = ex.Message;
#if DEBUG
message = ex.ToString();
#endif
Electron.Dialog.ShowErrorBox("Errore", $"Fallita creazione del file. {message}");
}
}
public void AttachExcelExportAction(IWebHostEnvironment env, AnagraficaFilarmonica ana = null)
{
if (HybridSupport.IsElectronActive)
{
Electron.IpcMain.RemoveAllListeners("export-excel-calcola");
Electron.IpcMain.On("export-excel-calcola", async(args) =>
{
BrowserWindow mainWindow = Electron.WindowManager.BrowserWindows.First();
var saveOptions = new SaveDialogOptions
{
Title = "Save a Excel File",
DefaultPath = await Electron.App.GetPathAsync(PathName.Documents),
Filters = new FileFilter[]
{
new FileFilter {
Name = "xlsx", Extensions = new string[] { "xlsx" }
}
}
};
string path = path = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, saveOptions);
if (string.IsNullOrEmpty(path))
{
return;
}
try
{
var modelloLista = new CalcoloListaRimborsiVM
{
Cognome = DatiCalcolo.Cognome,
Descrizione = DatiCalcolo.Descrizione,
Nome = DatiCalcolo.Nome,
Rimborsi = new List <CalcoloRimborsoVM> {
DatiCalcolo
},
SocioID = DatiCalcolo.SocioID,
TotaleDovuto = DatiCalcolo.TotaleDovuto,
TotaleReale = DatiCalcolo.TotaleReale
};
IExcelModel m = new RimborsoKmExcel(env, modelloLista)
{
Intestazione1 = ana?.RagioneSociale ?? "Società",
Intestazione2 = ana?.Citta
};
await m.SaveAs(path);
}
catch (Exception ex)
{
string message = ex.Message;
#if DEBUG
message = ex.ToString();
#endif
Electron.Dialog.ShowErrorBox("Errore", $"Fallita creazione del file. {message}");
}
});
}
}
/// <inheritdoc />
public async Task <string> ShowSaveDialogAsync(BrowserWindow browserWindow, SaveDialogOptions saveDialogOptions)
{
return(await Electron.Dialog.ShowSaveDialogAsync(browserWindow, saveDialogOptions));
}
public IActionResult Index()
{
var trayMenu = new MenuItem[] {
new MenuItem
{
Label = "Create Contact",
Click = () => Electron.WindowManager.BrowserWindows
.First()
.LoadURL($"http://localhost:{BridgeSettings.WebPort}/Contacts/Create")
},
new MenuItem
{
Label = "Remove",
Click = () => Electron.Tray.Destroy()
}
};
//Electron.Tray.Show("/Assets/GraphIcon Large.png", trayMenu);
var windowMenu = new MenuItem[] {
new MenuItem {
Label = "File", Submenu = new MenuItem[] {
new MenuItem
{
Label = "Open",
Accelerator = "CmdOrCtrl+O",
Click = async() =>
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
Electron.IpcMain.Send(mainWindow, "NEW_DOCUMENT_NEEDED", "Create new document");
/*var saveOptions = new SaveDialogOptions()
* {
* ButtonLabel = "Save",
* Filters = new FileFilter[]
* {
* new FileFilter { Extensions = new string[] { ".bhvr" } }
* },
* NameFieldLabel = "Behaviour"
* };
* string[] result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, saveOptions);*/
var openDialog = new OpenDialogOptions()
{
ButtonLabel = "Open",
Filters = new FileFilter[]
{
new FileFilter {
Extensions = new string[] { ".bhvr" }
}
}
};
string[] result = await Electron.Dialog.ShowOpenDialogAsync(mainWindow, openDialog);
var manager = new FileManager(result[0]);
FileManagers.Add(manager);
}
},
new MenuItem
{
Label = "New",
Accelerator = "CmdOrCtrl+N",
Click = async() =>
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
Electron.IpcMain.Send(mainWindow, "NEW_DOCUMENT_NEEDED", "Create new document");
var saveOptions = new SaveDialogOptions()
{
ButtonLabel = "Save",
Filters = new FileFilter[]
{
new FileFilter {
Extensions = new string[] { ".bhvr" }
}
},
NameFieldLabel = "Behaviour"
};
var result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, saveOptions);
string[] data = System.IO.File.ReadAllLines(result);
Console.WriteLine(string.Join('\n', data));
}
},
}
},
new MenuItem {
Label = "Edit", Submenu = new MenuItem[] {
new MenuItem {
Label = "Undo", Accelerator = "CmdOrCtrl+Z", Role = MenuRole.undo
},
new MenuItem {
Label = "Redo", Accelerator = "Shift+CmdOrCtrl+Z", Role = MenuRole.redo
},
new MenuItem {
Type = MenuType.separator
},
new MenuItem {
Label = "Cut", Accelerator = "CmdOrCtrl+X", Role = MenuRole.cut
},
new MenuItem {
Label = "Copy", Accelerator = "CmdOrCtrl+C", Role = MenuRole.copy
},
new MenuItem {
Label = "Paste", Accelerator = "CmdOrCtrl+V", Role = MenuRole.paste
},
new MenuItem {
Label = "Select All", Accelerator = "CmdOrCtrl+A", Role = MenuRole.selectall
}
}
},
new MenuItem {
Label = "View", Submenu = new MenuItem[]
{
new MenuItem
{
Label = "Reload",
Accelerator = "CmdOrCtrl+R",
Click = () =>
{
// on reload, start fresh and close any old
// open secondary windows
Electron.WindowManager.BrowserWindows.ToList().ForEach(browserWindow => {
if (browserWindow.Id != 1)
{
browserWindow.Close();
}
else
{
browserWindow.Reload();
}
});
}
},
new MenuItem
{
Label = "Toggle Full Screen",
Accelerator = "CmdOrCtrl+F",
Click = async() =>
{
bool isFullScreen = await Electron.WindowManager.BrowserWindows.First().IsFullScreenAsync();
Electron.WindowManager.BrowserWindows.First().SetFullScreen(!isFullScreen);
}
},
new MenuItem
{
Label = "Open Developer Tools",
Accelerator = "CmdOrCtrl+I",
Click = () => Electron.WindowManager.BrowserWindows.First().WebContents.OpenDevTools()
},
new MenuItem
{
Type = MenuType.separator
},
new MenuItem
{
Label = "App Menu Demo",
Click = async() => {
var options = new MessageBoxOptions("This demo is for the Menu section, showing how to create a clickable menu item in the application menu.");
options.Type = MessageBoxType.info;
options.Title = "Application Menu Demo";
await Electron.Dialog.ShowMessageBoxAsync(options);
}
}
}
},
new MenuItem {
Label = "Window", Role = MenuRole.window, Submenu = new MenuItem[] {
new MenuItem {
Label = "Minimize", Accelerator = "CmdOrCtrl+M", Role = MenuRole.minimize
},
new MenuItem {
Label = "Close", Accelerator = "CmdOrCtrl+W", Role = MenuRole.close
}
}
}
};
Electron.Menu.SetApplicationMenu(windowMenu);
return(View());
}
