text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>namespace ElectronNET.Runtime.Services.SocketBridge
{
using ElectronNET.API;
using ElectronNET.Runtime.Data;
using System;
using System.Threading.Tasks;
internal class SocketBridgeService : LifetimeServiceBase
{
private readonly int socketPort;
private readonly st... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.Runtime
{
using System;
using System.Collections.Immutable;
using System.Globalization;
using System.Linq;
using System.Reflection;
using ElectronNET.Runtime.Controllers;
using ElectronNET.Runtime.Data;
using ElectronNET.Runtime.Helpers;
internal... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>using ElectronNET.API.Entities;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace ElectronNET.API.Serialization
{
internal static class ElectronJson
{
public static readonly JsonSerializerOptions Options = new JsonSerializerOptions
{
PropertyNamin... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> writer.WriteStartObject();
writer.WriteEndObject();
}
}
}<|fim_prefix|>namespace ElectronNET.Serialization
{
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
public sealed class JsonToBoxed... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> .AddSingleton(_ => Dock.Instance);
}
}
<|fim_prefix|>namespace ElectronNET.API
{
using Microsoft.Extensions.DependencyInjection;
/// <summary>
///
/// </summary>
public static class ServiceCollectionExtensions
{
/// <summary>
/// Adds the <see cref="Electro... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>="WebApplicationBuilder"/> instance to enable fluent configuration.
/// </returns>
/// <example>
/// <code language="csharp">
/// var builder = WebApplication.CreateBuilder(args)
/// .UseElectron(args, async () =>
/// {
/// // Create ... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>ot localhost
var host = webPort == 0 ? "127.0.0.1" : "localhost";
if (Directory.Exists($"{AppDomain.CurrentDomain.BaseDirectory}\\wwwroot"))
{
builder = builder.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory)
.UseUrls($"http://... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>ameSiteMode.Strict, // CSRF protection
Path = "/", // Valid for all routes
Secure = false, // False because localhost is HTTP
IsEssential = true // Required for app ... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.AspNet.Runtime
{
using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.Extensions.DependencyInjection;
using ElectronNET.API;
using... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>idge(port, token);
}
private void ElectronProcess_Stopped(object sender, EventArgs e)
{
this.HandleStopped();
}
}
}
<|fim_prefix|>namespace ElectronNET.AspNet.Runtime
{
using System;
using System.Threading.Tasks;
using System.Security.Principal... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.AspNet.Runtime
{
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting.Server;
using ElectronNET.AspNet.Services;
using ElectronNET.Runtime.Data;
using ElectronNET.Runtime.Services.ElectronProcess;
internal class RuntimeControlle... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> return app =>
{
_ = app.ApplicationServices.GetService<AspNetLifetimeAdapter>();
var runtimeController = app.ApplicationServices.GetService<IElectronNetRuntimeController>();
runtimeController.Start();
next(app);
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> }
}
}<|fim_prefix|>namespace ElectronNET.AspNet.Runtime
{
using System.Threading.Tasks;
using ElectronNET.Runtime.Data;
using ElectronNET.Runtime.Services;
using Microsoft.Extensions.Hosting;
internal class AspNetLifetimeAdapter : LifetimeServiceBase
{
private... | fim | ElectronNET/Electron.NET | csharp |
namespace ElectronNET.AspNet.Services
{
/// <summary>
/// Implementation of authentication service for Electron clients.
/// Stores and validates the authentication token to ensure only the spawned Electron process can connect.
/// </summary>
public class ElectronAuthenticationService : IElectronAut... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>coming token against the expected token.
/// Uses constant-time comparison to prevent timing attacks.
/// </summary>
/// <param name="token">The token to validate</param>
/// <returns>True if token is valid, false otherwise</returns>
bool ValidateToken(string token)... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.Build
{
using System;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
public class DumpItemMetadataTask : Task
{
// The item group whose metadata will be dumped.
[Required]
public ITaskItem[] Items { get; set; }
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.Build
{
using Sys<|fim_suffix|>ntries);
foreach (var item in items)
{
Environment.SetEnvironmentVariable(item.Trim(), null);
this.Log.LogMessage("Unset environment variable: {0}", item);
}
... | fim | ElectronNET/Electron.NET | csharp |
namespace ElectronNET.Build
{
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
public class ReplaceTemplateTask : Task
{
[Required]
public string Temp... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>using ElectronNET.API;
namespace ElectronNET.WebApp
{
using System;
using System.Threading.Tasks;
using ElectronNET.API.Entities;
public class Program
{
public static async Task Main(string[] args)
{
var runtimeController = ElectronNetRuntime.RuntimeContr... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Connector = void 0;
const socket_io_1 = require("socket.io");
class Connector {
socket;
app;
c<|fim_suffix|> this.socket.emit(`${key}Error${id}`, `Host Hook Exception`, error);
}
... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|> javaScriptCode(...args, (data) => {
if (data) {
this.socket.emit(`${key}Complete${id}`, data);
}
});
} catch (error) {
this.socket.emit(`${key}Error${id}`, `Host Hook Exception`, error);
... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { en... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>void {
// execute your own JavaScript Host logic here
}
}
<|fim_prefix|>// @ts-ignore
import * as Electron from "electron";
import { Socket } from "socket.io";
import { Connector } from "./connector";
export class HookService extends Connector {
constructor(socket: Socket, public app: Ele... | fim | ElectronNET/Electron.NET | typescript |
<|fim_suffix|>("appGetFileIcon", async (path, options) => {
let error = {};
if (options) {
const nativeImage = await app
.getFileIcon(path, options)
.catch((errorFileIcon) => (error = errorFileIcon));
electronSocket.emit("appGetFileIconCompleted", ... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>> {
app.clearRecentDocuments();
});
socket.on("appSetAsDefaultProtocolClient", (protocol, path, args) => {
const success = app.setAsDefaultProtocolClient(protocol, path, args);
electronSocket.emit("appSetAsDefaultProtocolClientCompleted", success);
});
socket.on("appRemoveAsDefaultPr... | fim | ElectronNET/Electron.NET | typescript |
<|fim_suffix|>ateCheckResult);
})
.catch((error) => {
electronSocket.emit("autoUpdater-checkForUpdatesAndNotifyError" + guid, error);
});
});
socket.on("autoUpdater-checkForUpdates", async (guid) => {
electron_updater_1.autoUpdater
.checkForUpdates()
... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|> autoUpdater.channel = value;
});
socket.on("autoUpdater-requestHeaders", () => {
electronSocket.emit(
"autoUpdater-requestHeaders-completed",
autoUpdater.requestHeaders,
);
});
socket.on("autoUpdater-requestHeaders-set", (value) => {
autoUpdater.requestHeaders = value... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.browserViewMediateService = exports.browserViewApi = void 0;
const electron_1 = require("electron");
const browserViews = (global["browserViews"] =
global["browserViews"] || []);
const proxyToCredentialsMap = (global[... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { BrowserView } from "electron";
const browserViews: BrowserView[] = (global["browserViews"] =
global["browserViews"] || []) as BrowserView[];
const proxyToCredentialsMap: { [proxy: string]: string } = (global[
"proxyToCredentialsMap"
] = global["proxyToCrede... | fim | ElectronNET/Electron.NET | typescript |
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import * as path from "path";
import type { Socket } from "net";
import { BrowserWindow, Menu } from "electron";
import { browserViewMediateService } from "./browserView";
const windows: Electron.BrowserWindow[] = (global["browserWindows"] =
global["browserWindows"] || []) as Electron.BrowserWindow[];... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("clipboard-readText", (type) => {
const text = electron_1.clipboard.readText(type);
electronSocket.emit("clipboard-readText-completed", text);... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { clipboard, nativeImage } from "electron";
let elec<|fim_suffix|>ent = clipboard.readRTF(type);
electronSocket.emit("clipboard-readRTF-completed", content);
});
socket.on("clipboard-writeRTF", (text, type) => {
clipboard.writeHTML(text, type);
});... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
let electronSocket;
module.exports = (socket, app) => {
electronSocket = socket<|fim_suffix|>tSwitchValue", (the_switch) => {
const value = app.commandLine.getSwitchValue(the_switch);
electronSocket.emit("appCommandLineGetSwitchValueCompleted", value);
});
};
//# sour... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
let electronSocket: Socket;
export = (socket: Socket, app: Electron.App) => {
electronSocket = socket;
socket.on(
"appCommandLineAppendSwitch",
(the_switch: string, value: string) => {
app.commandLine.appendSwitch(the_switch, value);
},
);
s... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("showMessageBox", async (browserWindow, options, guid) => {
if ("id" in browserWindow) {
const window = electron_1.BrowserWindow.fromId(br... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|> content);
});
socket.on(
"showCertificateTrustDialog",
async (browserWindow, options, guid) => {
const window = BrowserWindow.fromId(browserWindow.id);
await dialog.showCertificateTrustDialog(window, options);
electronSocket.emit("showCertificateTrustDialogComplete" + guid... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("dock-bounce", (type) => {
const id = electron_1.app.dock.bounce(type);
electronSocket.emit("dock-bounce-completed", id);
});
<|fim_su... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>.on("dock-setMenu", (menuItems) => {
let menu = null;
if (menuItems) {
menu = Menu.buildFromTemplate(menuItems);
addMenuItemClickConnector(menu.items, (id) => {
electronSocket.emit("dockMenuItemClicked", id);
});
}
app.dock.setMenu(menu);
});
// TODO: Menu... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronS<|fim_suffix|>() => {
electronSocket.emit("globalShortcut-pressed", accelerator);
});
});
socket.on("globalShortcut-isRegistered", (accelerator) => {
co... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>tronSocket.emit("globalShortcut-pressed", accelerator);
});
});
socket.on("globalShortcut-isRegistered", (accelerator) => {
const isRegistered = globalShortcut.isRegistered(accelerator);
electronSocket.emit("globalShortcut-isRegisteredCompleted", isRegistered);
});
socket.on("global... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("registerIpcMainChannel", (channel) => {
electron_1.ipcMain.on(channel, (event, args) => {
electronSocket.emit(channel, [event.preventDefa... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { ipcMain, BrowserWindow, BrowserView, Menu } from "electron";
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
socket.on("registerIpcMainChannel", (channel) => {
ipcMain.on(channel, (event, args) => {
electronSoc... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
const contextMenuItems = (global["contextMenuItems"] =
global["contextMenuItems"] || []);
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("menu-setContextMenu", (browserWindowId, m<|fim_suffix|>(browser... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>erWindowId);
};
}
});
}
socket.on("menu-contextMenuPopup", (browserWindowId) => {
contextMenuItems.forEach((x) => {
if (x.browserWindowId === browserWindowId) {
const browserWindow = BrowserWindow.fromId(browserWindowId);
x.menu.popup(browserWindow);
... | fim | ElectronNET/Electron.NET | typescript |
"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("nativeTheme-shouldUseDarkColors", () => {
const shouldUseDarkColors = electron_1.nativeTheme.shouldUseDarkColors;
electronSocket.emit("nativeTheme-shouldUs... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { nativeTheme } from "electron";
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
socket.on("nativeTheme-shouldUseDarkColors", () => {
const shouldUseDarkColors = nativeTheme.shouldUseDarkColors;
electronSocket.em... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
const notifications = (global["notifications"] =
global["notifications"] || []);
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("createNotification", (options) => {
const notification = new ele... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { Notification } from "electron";
const notifications: Electron.Notification[] = (global["notifications"] =
global["notifications"] || []) as Electron.Notification[];
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
sock... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("register-powerMonitor-lock-screen", () => {
electron_1.powerMonitor.on("lock-screen", () => {
electronSocket.emit("powerMonitor-lock-scre... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { powerMonitor } from "electron";
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
socket.on("register-powerMonitor-lock-screen", () => {
powerMonitor.on("lock-screen", () => {
electronSocket.emit("powerMonitor-lo... | fim | ElectronNET/Electron.NET | typescript |
<|fim_suffix|>e = process.type;
electronSocket.emit("process-type-completed", value);
});
socket.on("process-versions", () => {
const value = process.versions;
electronSocket.emit("process-versions-completed", value);
});
socket.on("process-defaultApp", () => {
if (proces... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>rocess-upTime", () => {
let value = process.uptime();
if (value === undefined) {
value = -1;
}
electronSocket.emit("process-upTime-completed", value);
});
socket.on("process-pid", () => {
if (process.pid === undefined) {
electronSocket.emit("process-pid-completed", -1)... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("register-screen-display-added", (id) => {
electron_1.screen.on("display-added", (event, display) => {
electronSocket.emit("screen-display... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { screen } from "electron";
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
socket.on("register-screen-display-added", (id) => {
screen.on("display-added", (event, display) =><|fim_suffix|>-metrics-changed", (event, d... | fim | ElectronNET/Electron.NET | typescript |
"use strict";
const electron_1 = require("electron");
let electronSocket;
module.exports = (socket) => {
electronSocket = socket;
socket.on("shell-showItemInFolder", (fullPath) => {
electron_1.shell.showItemInFolder(fullPath);
electronSocket.emit("shell-showItemInFolderCompleted");
});
s... | fim | ElectronNET/Electron.NET | javascript |
<|fim_suffix|>lPath);
success = true;
} catch (error) {
success = false;
}
electronSocket.emit("shell-trashItem-completed", success);
});
socket.on("shell-beep", () => {
shell.beep();
});
socket.on("shell-writeShortcutLink", (shortcutPath, operation, options) => {
const succes... | fim | ElectronNET/Electron.NET | typescript |
<|fim_suffix|>k);
}
if ("id" in item && item.id) {
item.click = () => {
callback(item.id);
};
}
});
}
};
//# sourceMappingURL=tray.js.map<|fim_prefix|>"use strict";
const electron_1 = require("electron");
let tray = (glo... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import type { Socket } from "net";
import { Menu, Tray, nativeImage } from "electron";
let tray: { value: Electron.Tray } = (global["$tray"] = global["tray"] || {
value: null,
});
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
socket.on("register-tray-click", ... | fim | ElectronNET/Electron.NET | typescript |
<|fim_suffix|>.emit("webContents-session-clearStorageData-options-completed" + guid);
});
socket.on("webContents-session-createInterruptedDownload", (id, options) => {
const browserWindow = getWindowById(id);
browserWindow.webContents.session.createInterruptedDownload(options);
});
socke... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>import * as fs from "fs";
import type { Socket } from "net";
import { BrowserWindow, BrowserView } from "electron";
import { browserViewMediateService } from "./browserView";
let electronSocket: Socket;
export = (socket: Socket) => {
electronSocket = socket;
// The crashed event has been removed i... | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>module.exports = [
{
rules: {
<|fim_suffix|>ules here.
}
}
];<|fim_middle|> // Add r<|endoftext|> | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>const { app } = require('electron');
const { BrowserWindow } = require('electron');
const { createServer } = require('http');
const { randomUUID } = require('crypto');
const { Server } = require('socket.io');
const { platform } = require('os');
const path = require('path');
const fs = require('fs');
cons... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>global.process = undefined;<|fim_suffix|>global.module = undefined;
<|fim_middle|>
<|endoftext|> | fim | ElectronNET/Electron.NET | javascript |
// Simplified ambient module declarations to silence unresolved external module TS errors
// and missing extended tsconfig references inside node_modules.
// This is internal only.
declare module 'electron-updater' {
export const autoUpdater: any;
}
declare module '@ljharb/tsconfig';
<|endoftext|> | fim | ElectronNET/Electron.NET | typescript |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Common
{
using System.Runtime.InteropServices;
using Xunit.Sdk;
/// <summary>
/// Custom fact attribute with a default timeout of 20 seconds, allowing tests to be skipped on specific environments.
/// </summary>
/// <seealso cref="Xunit.Fact... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> public const string Linux = "Linux";
}
}
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Common
{
using ElectronNET.API;
using ElectronNET.API.Entities;
// Base class for integration tests providing shared access to MainWindow and OS platform constants
public abstract class... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests
{
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using ElectronNET.API;
using ElectronNET.API.Entities;
using ElectronNET.Common;
// Shared fixture that starts Electron runtime once
[SuppressMessage("ReSharper", "MethodHa... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>FluentAssertions;<|fim_prefix|>global using Xunit;
glo<|fim_middle|>bal using <|endoftext|> | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> status.Should().NotBeNull();
status.Webgl.Should().NotBeNull();
status.VideoDecode.Should().NotBeNull();
}
}
}
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.API;
using ElectronNET.API.Entities;
using System;
using System... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>Updater.RequestHeadersAsync;
test.Should().NotBeNull();
test.Count.Should().Be(1);
test["key1"].Should().Be("value1");
}
[IntegrationFact]
public async Task CheckForUpdatesAsync_check()
{
var test = await Electron.AutoUpdater... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>s());
this.MainWindow.SetBrowserView(view);
view.Bounds = new Rectangle { X = 0, Y = 0, Width = 300, Height = 200 };
// Access bounds again (synchronous property fetch)
var current = view.Bounds;
current.Width.Should().Be(300);
curren... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using System.Runtime.Versioning;
using ElectronNET.API;
using ElectronNET.API.Entities;
using ElectronNET.Common;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class BrowserWindowTests : Inte... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>tleTest", url);
var bookmark = await Electron.Clipboard.ReadBookmarkAsync();
bookmark.Url.Should().Be(url);
}
}
}
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using System.Runtime.Versioning;
using ElectronNET.API;
using ElectronNET.Integrati... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>n_cookie=1;path=/';");
await Task.Delay(500.ms());
changed.Should().BeTrue();
}
}
}<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.Common;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
publi... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>lectronNET.API;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class GlobalShortcutTests : IntegrationTestBase
{
public GlobalShortcutTests(ElectronFixture fx) : base(fx)
{
}
[IntegrationFact]
public async Task... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> result.Should().NotBeNull();
}
}
}<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.API;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class HostHookTests : IntegrationTestBase
{
public HostHookT... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.<|fim_suffix|>s_value()
{
object received = null;
Electron.IpcMain.OnSync("ipc-sync-test", (obj) =>
{
received = obj;
return "pong";
});
var ret = await this.MainWindow.WebContents.Ex... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> fx) : base(fx)
{
}
[IntegrationFact]
public async Task ApplicationMenu_click_invokes_handler()
{
var clicked = false;
var items = new[]
{
new MenuItem
{
Label = "File",
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>e="Build" DependsOnTargets="ElectronMigrationChecks" />
</Project>
""");
}
private static async Task<(int ExitCode, string Output)> RunDotnetBuildAsync(string workingDirectory)
{
var psi = new ProcessStartInfo("dotnet", "build --nologo -v:minimal")
{
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>bout:blank");
var ok = await WaitAllOrTimeout(TimeSpan.FromSeconds(2), r1.Task, r2.Task);
if (!ok)
{
throw new Xunit.Sdk.XunitException($"Not all events were fired: \nEvent1 fired: {r1.Task.IsCompleted}\nEvent2 fired: {r2.Task.IsCompleted}");
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>using System.Drawing;
using ElectronNET.API.Entities;
using ElectronNET.IntegrationTests.Common;
using System.Runtime.Versioning;
using RectangleEntity = ElectronNET.API.Entities.Rectangle;
namespace ElectronNET.IntegrationTests.Tests
{
[Collection("ElectronCollection")]
[SupportedOSPlatform(Wind... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using System.Runtime.Versioning;
using ElectronNET.API;
using ElectronNET.API.Entities;
using ElectronNET.Common;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class NativeThemeTests : Integr... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using System.Runtime.InteropServices;
using ElectronNET.API;
using ElectronNET.API.Entities;
using ElectronNET.Common;
using ElectronNET.IntegrationTests.Common;
[Collection("<|fim_suffix|>ght need full-blown desktop environment");
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.API;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class ProcessTests : IntegrationTestBase
{
public ProcessTests(ElectronFixture fx) : base(fx)
{
}
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using System.Runtime.Versioning;
using ElectronNET.API;
using ElectronNET.API.Entities;
using ElectronNET.In<|fim_suffix|> async Task GetDisplayMatching_check()
{
var rectangle = new Rectangle
{
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.API.Entities;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class SessionTests : IntegrationTestBase
{
public SessionTests(ElectronFixture fx) : base(fx)
{
}... | fim | ElectronNET/Electron.NET | csharp |
namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.API;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class ShellTests : IntegrationTestBase
{
public ShellTests(ElectronFixture fx) : base(fx)
{
}
[IntegrationFact(... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>p if icon missing
}
var tcs = new TaskCompletionSource<bool>();
var btn = new ThumbarButton(icon) { Tooltip = "Test", Flags = new[] { ThumbarButtonFlag.enabled }, Click = () => tcs.TrySetResult(true) };
var ok = await this.MainWindow.SetThumbarButtonsAsync(... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>IsDestroyedAsync()).Should().BeTrue();
}
}
}<|fim_prefix|>namespace ElectronNET.IntegrationTests.Tests
{
using ElectronNET.API;
using ElectronNET.IntegrationTests.Common;
[Collection("ElectronCollection")]
public class TrayTests : IntegrationTestBase
{
public TrayT... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>Deserialize<UpdateInfo>(json, Options);
result.Should().NotBeNull();
result.ReleaseNotes.Should().NotBeNull();
result.ReleaseNotes.Should().BeEmpty();
}
// Empty array must serialize as [] not null, so round-trips and downstream
// consumers do... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> public async Task GetSetAudioMuted_check()
{
this.MainWindow.WebContents.SetAudioMuted(true);
await Task.Delay(500.ms());
var ok = await this.MainWindow.WebContents.IsAudioMutedAsync();
ok.Should().BeTrue();
this.MainWindow.WebContent... | fim | ElectronNET/Electron.NET | csharp |
// Set up event handlers
const reconnectModal = document.getElementById("components-reconnect-modal");
reconnectModal.addEventListener("components-reconnect-state-changed", handleReconnectStateChanged);
const retryButton = document.getElementById("components-reconnect-button");
retryButton.addEventListener("click", re... | fim | ElectronNET/Electron.NET | javascript |
<|fim_prefix|>using ElectronNET.API;
using ElectronNET.API.Entities;
using ElectronNET.AspNet.Middleware;
using ElectronNET.AspNet.Services;
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorComp... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>using ElectronNET.API;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
namespace ElectronNET.Samples.ElectronHostHook.Controllers
{
public class HomeController : Con<|fim_suffix|>', Received: '{result}'";
}
return View("Index", message);
}
}
}
<|fim_... | fim | ElectronNET/Electron.NET | csharp |
<|fim_prefix|>import { Socket } from "socket.io";
export class Connector {
constructor(private socket: Socket, public app: any) {
}
on(key: string, javaScriptCode: Function): void {
this.socket.on(key, (...args: any[]) => {
const id: string = args.pop();
try {
... | fim | ElectronNET/Electron.NET | typescript |
<|fim_suffix|> => {
console.log("Received ping from C#:", msg);
done("pong: " + msg);
});
}
}
<|fim_prefix|>import { Connector } from "./connector";
import { Socket } from "socket.io";
export class HookService extends Connector {
constructor(socket: Socket, public app: any) {
... | fim | ElectronNET/Electron.NET | typescript |
using ElectronNET.API;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
namespace ElectronNET.Samples.ElectronHostHook
{
public class Program
{
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
... | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|>espace ElectronNET.WebApp.Controllers
{
public class AboutController : Controller
{
public IActionResult Index()
{
return View();
}
}
}<|fim_prefix|>using Microsoft.As<|fim_middle|>pNetCore.Mvc;
nam<|endoftext|> | fim | ElectronNET/Electron.NET | csharp |
<|fim_suffix|> });
Electron.IpcMain.On("sys-info", async (args) =>
{
string homePath = await Electron.App.GetPathAsync(PathName.Home);
var mainWindow = Electron.WindowManager.BrowserWindows.First();
Electron.IpcMain.Sen... | fim | ElectronNET/Electron.NET | csharp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.