We're starting a monthly roundup to highlight activity in the Electron community. Each roundup will feature things like new apps, upcoming meetups, tools, videos, etc.

This site is updated with new apps and meetups through pull requests from the community. Vous pouvez surveiller le dépôt pour être informé des nouveaux ajouts ou, si vous n'êtes pas intéressé par toutes les modifications du site, vous pouvez vous abonner au fil RSS du blog.

Si vous avez créé une application Electron ou si vous organisez une réunion, faites une requête pour l'ajouter au site et elle fera partie du prochain regroupement.

Nouvelles applications​

	Demio	A Webinar platform built for inbound sales and marketing
	Electorrent	A remote client app for uTorrent server
	PhoneGap	The open source framework that gets you building amazing mobile apps using web technology
	WordMark	A lightweight blog publishing editor for Markdown writers
	UbAuth	App to help developers create access tokens for Uber applications with OAuth 2.0
	HyperTerm	HTML/JS/CSS terminal
	Marp	Markdown presentation writer
	Glyphr Studio	A free, web based font designer, focusing on font design for hobbyists
	BitCrypt	A simple file encryption application for Windows Encrypt your bits
	Trym	Beautiful small app for macOS to help you view, optimize and convert SVG icons
	Booker	Text editor with the power of Markdown
	PhonePresenter	The smartest presentation clicker
	Yout	The new way to watch your playlists from YouTube on desktop

New Meetups​

C'est le premier article d'une série qui explique le fonctionnement interne d'Electron. Cet article présente comment la boucle d’événements de Node est intégrée dans Electron avec Chromium.

Il y a eu de nombreuses tentatives d'utiliser Node pour la programmation GUI, comme node-gui pour les liaisons avec GTK+ et node-qt pour les liaisons avec QT. Mais aucune d'entre elle ne fonctionne en production parce que les kits d'outils d'interface graphique ont leurs propres boucles de message tandis que Node utilise libuv pour sa propre boucle d'événement, et le thread principal ne peut exécuter qu'une seule boucle en même temps. Ainsi, l’astuce courante pour exécuter la boucle de message GUI dans Node consiste à activer la boucle de message par l'intermédiaire d'un timer avec un très petit intervalle, ce qui ralentit la réponse de l’interface graphique et occupe beaucoup de ressources CPU.

Lors du développement d'Electron, nous avons rencontré le même problème, bien que de manière inversée : nous devions intégrer la boucle d'événements de Node dans la boucle message de Chromium.

Le processus principal et le processus de rendu​

Avant de plonger dans les détails de l'intégration de la boucle de messages, je vais d'abord expliquer l'architecture multi-processus de Chromium.

Dans Electron, il y a deux types de processus : le processus principal et le processus de rendu (ceci est en fait extrêmement simplifié, pour une vue complète, voir Architecture multi-processus). Le processus principal est responsable de l'interface utilisateur comme la création de fenêtres, tandis que le processus de rendu ne s'occupe que de l'exécution et du rendu des pages Web.

Electron permet d'utiliser JavaScript pour contrôler à la fois le processus principal et le processus de rendu, ce qui signifie que nous devons intégrer Node dans les deux processus.

Remplacement de la boucle de message de Chromium par libuv​

Ma première tentative fut de ré implémenter la boucle de message de Chromium avec libuv.

C'était facile pour le processus de rendu car sa boucle de message n'écoutait que les descripteurs de fichiers et les timers et je n'avais besoin que d'implémenter l'interface avec libuv.

Cependant, c’était beaucoup plus difficile pour le processus principal. Chaque plate-forme a son propre type de boucles de messages GUI. macOS Chromium utilise NSRunLoop, alors que Linux utilise glib. J'ai essayé de nombreux hacks pour extraire les descripteurs de fichiers sous-jacents des boucles de messages de l'interface native, et puis les fournir à libuv pour itération, mais j'ai toujours rencontré des cas particuliers qui ne fonctionnaient pas.

J'ai donc finalement ajouté un timer pour interroger la boucle du message de l'interface dans un petit intervalle. Comme un résultat le processus a une utilisation constante du processeur, et certaines opérations ont de longs retards.

Scrutation de la boucle d’événements de Node dans un thread distinct​

Comme libuv a mûri, il a été possible d’adopter une autre approche.

Le concept de fd backend a été introduit dans libuv, qui est un descripteur de fichier (ou un manipulateur) que libuv interroge pour sa boucle d'événements. Donc, en interrogeant le backend fd, il est possible d’être averti lorsqu’il y a un nouvel événement dans libuv.

Donc, dans Electron, j'ai créé un thread séparé pour interroger le backend fd, et puisque j'utilise les appels du système pour scruter au lieu des API libuv, c'est thread safe sûr. Et chaque fois qu'il y a un nouvel événement dans la boucle d'événement de libuv, un message est posté dans la boucle de message de Chromium, et les événements de libuv sont alors traités dans le thread principal.

De cette façon, j'ai évité de patcher Chromium et Node, et le même code a été utilisé dans à la fois les processus principal et de rendu.

Le code​

Vous pouvez trouver l'implémentation de l'intégration de la boucle message dans les fichiers node_bindings sous electron/atom/common/. Il peut être facilement réutilisé pour les projets souhaitant intégrer Node.

Update: l'Implementation a été déplacée dans electron/shell/common/node_bindings.cc.

Looking for an introduction to Electron? Two new podcasts have just been released that give a great overview of what it is, why it was built, and how it is being used.

Out now:

Hanselminutes: Creating cross-platform Electron apps​

Is Electron "just Chrome in a frame" or is it so much more? Jessica sets Scott on the right path and explains exactly where the Electron platform fits into your development world.

JavaScript Air: Electron Apps​

Electron is becoming more and more of a relevant and popular way of building multi-platform desktop apps with web technologies. Let's get a dive into this awesome tech and see how we can use it to enhance our own experience and our user's experience on the desktop.

If you're looking for an introduction to Electron, give the first a listen. The second goes into more detail about building apps with great tips from Nylas's Evan Morikawa.

We are currently working on two more podcasts that should come out next month, keep an eye on the @ElectronJS Twitter account for updates.

Au cours des deux dernières années, Electron a aidé des développeurs à créer des applications de bureau multiplateformes en utilisant HTML, CSS et JavaScript. Maintenant, nous sommes ravis de partager une étape majeure pour notre framework et pour la communauté qui l'a créé. La version d'Electron 1.0 est maintenant disponible sur electronjs.org.

Electron 1.0 représente un jalon majeur dans la stabilité et la maturité de l'API. Cette version vous permet de construire des applications qui agissent et se sentent vraiment natives sur Windows, Mac, et Linux. Construire des applications Electron est plus facile que jamais avec de nouvelles documentations, nouveaux outils et une nouvelle application pour vous guider à travers les API Electron.

Si vous êtes prêt à construire votre toute première application Electron, voici un guide de démarrage rapide pour vous aider à démarrer.

Nous sommes heureux de voir ce que vous construisez ensuite avec Electron.

Chemin d'Electron​

Nous avons libéré Electron lorsque nous avons lancé Atom il y a un peu plus de deux ans. Electron, alors connu sous le nom de Atom Shell, était le framework que nous avions construit sur Atom. À cette époque, Atom était la force motrice derrière les fonctionnements et les fonctionnalités qu'Electron a fourni en même temps que nous avons poussé à sortir la version initiale de Atom.

La conduite d'Electron est maintenant une communauté grandissante de développeurs et de sociétés qui construisent tout depuis email, chat, et Applications Git à Outils d'analyse SQL, clients torrent, et robots.

Au cours de ces deux dernières années, nous avons vu à la fois des entreprises et des projets open source choisir Electron comme base pour leurs applications. Juste au cours de l'année écoulée, Electron a été téléchargé plus de 1,2 million de fois. Faites une visite de quelques des incroyables applications Electron et ajoutez vos propres applications si elles ne sont pas déjà là.

Electron API Demos​

Along with the 1.0 release, we're releasing a new app to help you explore the Electron APIs and learn more about how to make your Electron app feel native. L'application Electron API Demos contient des extraits de code pour vous aider à démarrer votre application et des conseils sur l'utilisation efficace des API Electron.

Devtron​

We've also added a new extension to help you debug your Electron apps. Devtron est une extension open-source pour les outils de développement Chrome conçue pour vous aider à inspecter, débogage, et dépannage de votre application Electron.

Fonctionnalités​

• Require graph that helps you visualize your app's internal and external library dependencies in both the main and renderer processes
• IPC monitor that tracks and displays the messages sent and received between the processes in your app
• Event inspector that shows you the events and listeners that are registered in your app on the core Electron APIs such as the window, app, and processes
• App Linter that checks your apps for common mistakes and missing functionality

Spectron​

Enfin, nous publions une nouvelle version de Spectron, le framework de test d'intégration pour les applications Electron.

Spectron 3.0 has comprehensive support for the entire Electron API allowing you to more quickly write tests that verify your application's behavior in various scenarios and environments. Spectron est basé sur ChromeDriver et WebDriverIO donc il a également des API complètes pour la navigation de page, utilisateur entrée, et l'exécution JavaScript.

Communauté​

Electron 1.0 is the result of a community effort by hundreds of developers. Outside of the core framework, there have been hundreds of libraries and tools released to make building, packaging, and deploying Electron apps easier.

Il y a maintenant une nouvelle page communauté qui répertorie de nombreux outils Electron, applications, bibliothèques et frameworks en cours de développement. Vous pouvez également consulter les organisations Electron et Electron Userland pour voir certains de ces projets fantastiques.

New to Electron? Regardez la vidéo d'intro d'Electron 1.0 :

Electron 0.37 was recently released and included a major upgrade from Chrome 47 to Chrome 49 and also several new core APIs. This latest release brings in all the new features shipped in Chrome 48 and Chrome 49. This includes CSS custom properties, increased ES6 support, KeyboardEvent improvements, Promise improvements, and many other new features now available in your Electron app.

Quoi de neuf​

Propriétés personnalisées CSS​

Si vous avez utilisé des langages prétraités comme Sass et Less, vous êtes probablement familier avec les variables __, qui vous permettent de définir des valeurs réutilisables pour des choses comme les modèles de couleurs et les mises en page. Variables help keep your stylesheets DRY and more maintainable.

CSS custom properties are similar to preprocessed variables in that they are reusable, but they also have a unique quality that makes them even more powerful and flexible: they can be manipulated with JavaScript. Cette fonctionnalité subtile mais puissante permet des changements dynamiques aux interfaces visuelles tout en profitant de l'accélération matérielle du CSS, et réduit la duplication de code entre votre code frontend et vos feuilles de style.

For more info on CSS custom properties, see the MDN article and the Google Chrome demo.

Variables CSS en action​

Voyons un exemple de variable simple qui peut être ajusté en direct dans votre application.

:root {
  --awesome-color: #a5ecfa;
}

body {
  background-color: var(--awesome-color);
}

La valeur de la variable peut être récupérée et modifiée directement en JavaScript :

// Get the variable value ' #A5ECFA'
let color = window
  .getComputedStyle(document.body)
  .getPropertyValue('--awesome-color');

// Set the variable value to 'orange'
document.body.style.setProperty('--awesome-color', 'orange');

Les valeurs de la variable peuvent également être modifiées à partir de la section Styles des outils de développement pour un feedback rapide et des ajustements :

Propriété KeyboardEvent.code​

Chrome 48 added the new code property available on KeyboardEvent events that will be the physical key pressed independent of the operating system keyboard layout.

This should make implementing custom keyboard shortcuts in your Electron app more accurate and consistent across machines and configurations.

window.addEventListener('keydown', function (event) {
  console.log(`${event.code} was pressed.`);
});

Consultez cet exemple pour le voir en action.

Promise Rejection Events​

Chrome 49 added two new window events that allow you to be notified when an rejected Promise goes unhandled.

window.addEventListener('unhandledrejection', function (event) {
  console.log('A rejected promise was unhandled', event.promise, event.reason);
});

window.addEventListener('rejectionhandled', function (event) {
  console.log('A rejected promise was handled', event.promise, event.reason);
});

Consultez cet exemple pour le voir en action.

Mises à jour ES2015 en V8​

La version de V8 maintenant dans Electron incorpore 91 % de ES2015. Voici quelques ajouts intéressants que vous pouvez utiliser sans options ni pré-compilateurs :

Paramètres par défaut​

function multiply(x, y = 1) {
  return x * y;
}

multiply(5); // 5

Affectation par décomposition​

Chrome 49 added destructuring assignment to make assigning variables and function parameters much easier.

This makes Electron requires cleaner and more compact to assign now:

Browser Process Requires​

const { app, BrowserWindow, Menu } = require('electron');

Renderer Process Requires​

const { dialog, Tray } = require('electron').remote;

Autres exemples​

// Destructuring an array and skipping the second element
const [first, , last] = findAll();

// Destructuring function parameters
function whois({ displayName: displayName, fullName: { firstName: name } }) {
  console.log(`${displayName} is ${name}`);
}

let user = {
  displayName: 'jdoe',
  fullName: {
    firstName: 'John',
    lastName: 'Doe',
  },
};
whois(user); // "jdoe is John"

// Destructuring an object
let { name, avatar } = getUser();

Nouvelles API Electron​

A few of the new Electron APIs are below, you can see each new API in the release notes for Electron releases.

show and hide events on BrowserWindow​

These events are emitted when the window is either shown or hidden.

const { BrowserWindow } = require('electron');

let window = new BrowserWindow({ width: 500, height: 500 });
window.on('show', function () {
  console.log('Window was shown');
});
window.on('hide', function () {
  console.log('Window was hidden');
});

platform-theme-changed on app for OS X​

This event is emitted when the system’s Dark Mode theme is toggled.

const { app } = require('electron');

app.on('platform-theme-changed', function () {
  console.log(`Platform theme changed. In dark mode? ${app.isDarkMode()}`);
});

app.isDarkMode() pour OS X​

Cette méthode retourne true si le système est en Mode Sombre, ou false autrement.

scroll-touch-begin and scroll-touch-end events to BrowserWindow for OS X​

These events are emitted when the scroll wheel event phase has begun or has ended.

const { BrowserWindow } = require('electron');

let window = new BrowserWindow({ width: 500, height: 500 });
window.on('scroll-touch-begin', function () {
  console.log('Scroll touch started');
});
window.on('scroll-touch-end', function () {
  console.log('Scroll touch ended');
});

Building an Electron application means you only need to create one codebase and design for one browser, which is pretty handy. But because Electron stays up to date with Node.js and Chromium as they release, you also get to make use of the great features they ship with. In some cases this eliminates dependencies you might have previously needed to include in a web app.

There are many features and we'll cover some here as examples, but if you're interested in learning about all features you can keep an eye on the Google Chromium blog and Node.js changelogs. You can see what versions of Node.js, Chromium and V8 Electron is using at electronjs.org/#electron-versions.

ES6 Support through V8​

Electron combines Chromium's rendering library with Node.js. The two share the same JavaScript engine, V8. Many ECMAScript 2015 (ES6) features are already built into V8 which means you can use them in your Electron application without any compilers.

Below are a few examples but you can also get classes (in strict mode), block scoping, promises, typed arrays and more. Check out this list for more information on ES6 features in V8.

Arrow Functions

findTime () => {
  console.log(new Date())
}

String Interpolation

var octocat = 'Mona Lisa';
console.log(`The octocat's name is ${octocat}`);

New Target

Octocat() => {
  if (!new.target) throw "Not new";
  console.log("New Octocat");
}

// Throws
Octocat();
// Logs
new Octocat();

Array Includes

// Returns true
[1, 2].includes(2);

Rest Parameters

// Represent indefinite number of arguments as an array
(o, c, ...args) => {
  console.log(args.length);
};

Chromium Features​

Thanks to all the hard work Google and contributors put into Chromium, when you build Electron apps you can also use cool things like (but not limited to):

• MouseEvent.getModifierState()
• CSS.escape()
• Fetch API Streaming

Follow along with the Google Chromium blog to learn about features as new versions ship and again, you can check the version of Chromium that Electron uses here.

What are you excited about?​

Tweet to us @ElectronJS with your favorite features built into V8 or Chromium.

Since the beginning of Electron, starting way back when it used to be called Atom-Shell, we have been experimenting with providing a nice cross-platform JavaScript API for Chromium's content module and native GUI components. The APIs started very organically, and over time we have made several changes to improve the initial designs.

Now with Electron gearing up for a 1.0 release, we'd like to take the opportunity for change by addressing the last niggling API details. The changes described below are included in 0.35.x, with the old APIs reporting deprecation warnings so you can get up to date for the future 1.0 release. An Electron 1.0 won't be out for a few months so you have some time before these changes become breaking.

Deprecation warnings​

Par défaut, des avertissements s'afficheront si vous utilisez des API obsolètes. To turn them off you can set process.noDeprecation to true. To track the sources of deprecated API usages, you can set process.throwDeprecation to true to throw exceptions instead of printing warnings, or set process.traceDeprecation to true to print the traces of the deprecations.

New way of using built-in modules​

Les modules intégrés sont maintenant regroupés en un seul module, au lieu d'être séparés en modules indépendants, pour que vous puissiez les utiliser sans conflits avec d'autres modules :

var app = require('electron').app;
var BrowserWindow = require('electron').BrowserWindow;

The old way of require('app') is still supported for backward compatibility, but you can also turn if off:

require('electron').hideInternalModules();
require('app'); // throws error.

An easier way to use the remote module​

Because of the way using built-in modules has changed, we have made it easier to use main-process-side modules in renderer process. You can now just access remote's attributes to use them:

// New way.
var app = require('electron').remote.app;
var BrowserWindow = require('electron').remote.BrowserWindow;

Instead of using a long require chain:

// Old way.
var app = require('electron').remote.require('app');
var BrowserWindow = require('electron').remote.require('BrowserWindow');

Splitting the ipc module​

The ipc module existed on both the main process and renderer process and the API was different on each side, which is quite confusing for new users. We have renamed the module to ipcMain in the main process, and ipcRenderer in the renderer process to avoid confusion:

// Dans le processus principal .
var ipcMain = require('electron').ipcMain;

// In renderer process.
var ipcRenderer = require('electron').ipcRenderer;

And for the ipcRenderer module, an extra event object has been added when receiving messages, to match how messages are handled in ipcMain modules:

ipcRenderer.on('message', function (event) {
  console.log(event);
});

Standardizing BrowserWindow options​

The BrowserWindow options had different styles based on the options of other APIs, and were a bit hard to use in JavaScript because of the - in the names. They are now standardized to the traditional JavaScript names:

new BrowserWindow({ minWidth: 800, minHeight: 600 });

Following DOM's conventions for API names​

The API names in Electron used to prefer camelCase for all API names, like Url to URL, but the DOM has its own conventions, and they prefer URL to Url, while using Id instead of ID. We have done the following API renames to match the DOM's styles:

• Url is renamed to URL
• Csp is renamed to CSP

You will notice lots of deprecations when using Electron v0.35.0 for your app because of these changes. An easy way to fix them is to replace all instances of Url with URL.

Changes to Tray's event names​

The style of Tray event names was a bit different from other modules so a rename has been done to make it match the others.

• clicked is renamed to click
• double-clicked is renamed to double-click
• right-clicked is renamed to right-click

Recently Electron added two exciting features: a Mac App Store compatible build and a built-in Windows auto updater.

Mac App Store Support​

As of v0.34.0 each Electron release includes a build compatible with the Mac App Store. Previously an application built on Electron would not comply with Apple's requirements for the Mac App Store. Most of these requirements are related to the use of private APIs. In order to sandbox Electron in such a way that it complies with the requirements two modules needed to be removed:

• crash-reporter
• auto-updater

Additionally some behaviors have changed with respect to detecting DNS changes, video capture and accessibility features. You can read more about the changes and submitting your app to the Mac App store in the documentation. The distributions can be found on the Electron releases page, prefixed with mas-.

Related Pull Requests: electron/electron#3108, electron/electron#2920

Windows Auto Updater​

In Electron v0.34.1 the auto-updater module was improved in order to work with Squirrel.Windows. This means that Electron ships with easy ways for auto updating your app on both OS X and Windows. You can read more on setting up your app for auto updating on Windows in the documentation.

Related Pull Request: electron/electron#1984

Il y a eu quelques mises à jour et discussions intéressantes sur Electron récemment, voici un récapitulatif.

Source​

Electron est maintenant à jour avec Chrome 45 à partir de la version v0.32.0. Les autres mises à jour comprennent...

Amélioration de la documentation​

Nous avons restructuré et normalisé la documentation pour qu'elle soit plus attrayante et plus lisible. Il existe également des traductions de la documentation fournies par la communauté, comme le japonais et le coréen.

Related pull requests: electron/electron#2028, electron/electron#2533, electron/electron#2557, electron/electron#2709, electron/electron#2725, electron/electron#2698, electron/electron#2649.

Node.js 4.1.0​

Depuis la version v0.33.0 Electron est livré avec Node.js 4.1.0.

Questions apparentées : electron/electron#2817.

node-pre-gyp​

Les modules reposant sur node-pre-gyp peuvent désormais être compilés dans Electron lors de la compilation à partir des sources.

Demande de téléchargement connexe : mapbox/node-pre-gyp#175.

Support ARM​

Electron fournit maintenant des modules pour Linux sur ARMv7. Il fonctionne sur des plateformes populaires comme le Chromebook et le Raspberry Pi 2.

Questions apparentées : atom/libchromiumcontent#138, electron/electron#2094, electron/electron#366.

Fenêtre sans cadre façon Yosemite​

Un correctif par @jaanus a été fusionné qui, comme les autres applications OS X intégrées, permet de créer des fenêtres sans cadre avec le système de feux de circulation intégré sur OS X Yosemite et les versions ultérieures.

Questions apparentées : electron/electron#2776.

Google Summer of Code, support d'impression​

Après le Google Summer of Code nous avons fusionné des correctifs de @hokein pour améliorer le support de l'impression et ajoutez la possibilité d'imprimer la page dans des fichiers PDF.

Questions apparentées : electron/electron#2677, electron/electron#1935, electron/electron#1532, electron/electron#805, electron/electron#1669, electron/electron#1835.

Atom​

Atom a maintenant été mis à jour vers Electron v0.30.6 qui fonctionne avec Chrome 44. Une mise à jour vers la v0.33.0 est en cours sur atom/atom#8779.

Talks​

Amy Palamountain, membre de GitHubber, a présenté une excellente introduction à Electron lors d'une conférence à Nordic.js. Elle a également créé la bibliothèque electron-accelerator.

Créer des applications natives avec Electron par Amy Palomountain​

Ben OgleBen Ogle, qui fait également partie de l'équipe Atom, a donné une conférence sur Electron à YAPC Asia :

Création d'Applications de Bureau avec les Technologies Web par Ben Ogle​

Un membre de l'équipe Atom Kevin Sawicki et d'autres personnes ont récemment donné des conférences sur Electron lors de la réunion Bay Are Electron User Group. Les vidéos ont été postées, en voici quelques-unes :

L'histoire d'Electron par Kevin Sawicki​

Comment rendre une application web native par Ben Gotow​

Join us September 29th at GitHub's HQ for an Electron meetup hosted by Atom team members @jlord and @kevinsawicki. There will be talks, food to snack on, and time to hangout and meet others doing cool things with Electron. We'll also have a bit of time to do lightning talks for those interested. Nous espérons te revoir bientôt !

Talks

• Jonathan Ross and Francois Laberge from Jibo will share how they use Electron to animate a robot.
• Jessica Lord will talk about building a teaching tool, Git-it, on Electron.
• Tom Moor will talk about the pros and cons of building video and screen sharing on Electron with speak.io.
• Ben Gotow will preview N1: The Nylas Mail Client and talk about developing it on Electron.

Détails​

• Location: GitHub HQ, 275 Brannan Street, San Francisco, CA, 94107
• Date: Tuesday, September 29th, 2015
• Time: 6pm - 9pm
• RSVP: ti.to/github-events/electron-meetup