Mcs.Electron-desktop-javascript-language (Ljel)

cpt-created: {2017-07-11}

description-of-Ljel

description::
Electron-language is a-desktop-javascript-language developed by GitHub.
[HmnSgm.2017-07-11]

name::
* cpt.filMcsLjel.last.html,
* cpt.dirTchInf/filMcsLjel.last.html,
* cpt.Atom-Shell-language-(Ljel), (Previous name)
* cpt.Electron-desktop-javascript-language-(Ljel),
* cpt.Electronjs,
* cpt.Electronjs-(Ljel),
* cpt.Electronjs-language-(Ljel),
* cpt.Electronjs-language-(Ljel),
* cpt.javascript.Electron,
* cpt.javascriptElectron,
* cpt.Ljel,
* cpt.Ljel-(Electron-desktop-javascript-language),

description::
Electron-language is a-desktop-javascript-language developed by GitHub.
[HmnSgm.2017-07-11]
===
The Electron framework lets you write cross-platform desktop applications using JavaScript, HTML and CSS. It is based on Node.js and Chromium and is used by the Atom editor and many other apps.
[https://github.com/electron/electron]
===
Electron is an open source library developed by GitHub for building cross-platform desktop applications with HTML, CSS, and JavaScript.
Electron accomplishes this by combining Chromium and Node.js into a single runtime and apps can be packaged for Mac, Windows, and Linux.
[https://electron.atom.io/docs/tutorial/about/]

archetype-of-Ljel

Generic::
* Javascript-archetype,

document-of-Ljel (Ljel-doc)

Generic::
* Javascript-algorithm,

name::
* cpt.Ljel'algorithm,
* cpt.Ljel'document,
* cpt.Ljel-doc,

Ljel-doc'syntax-tree

description::
An-Ljel-algorithm is-comprised on one main-process syntax-tree and one or more renderer-processes syntax-trees.
[HmnSgm.2017-10-26]

name::
* cpt.Ljel'syntax-tree,
* cpt.Ljel-algo'syntax-tree,
* cpt.Ljel-syntax-tree,

Generic::
* Javascript--syntax-tree,

Ljel-doc'accelerator

description::
In Electron, keyboard shortcuts are called accelerators.
They can be assigned to action in your application's Menu, or they can be assigned globally so they'll be triggered even when your app doesn't have keyboard focus.
[Electron API Demos]

name::
* cpt.Ljel'accelerator,
* cpt.Ljel'keyboard-shortcut,
* cpt.Ljel'shortcut,

Ljel-doc'Api

name::
* cpt.Api.Electron,
* cpt.Api.Ljel,
* cpt.Electronjs'Api,
* cpt.Ljel'Api,
* cpt.Ljel-algo'Api,
* cpt.Ljel-Api,

Generic::
* Javascript-Api,

Ljel-Api'process

description::
A process is an instance of a computer program that is being executed. Electron apps that make use of the main and one or many renderer process are actually running several programs simultaneously.
In Node.js and Electron, each running process has a process object. This object is a global that provides information about, and control over, the current process. As a global, it is always available to applications without using require().
[https://github.com/electron/electron/blob/master/docs/glossary.md#process]
===
First off, what do you mean “process”?
I mean an operating system level process, or as Wikipedia puts it “an instance of a computer program that is being executed”. Crystal clear, right? For example, if I start an Electron application and then check the Activity Monitor in macOS, I can see how many processes are associated with that program.
Each of these processes run concurrently to each other. The most important thing to remember here is that processes’ memory and resources are isolated from each other.
[https://codeburst.io/deep-dive-into-electrons-main-and-renderer-processes-7a9599d5c9e2]

name::
* cpt.Ljel'process,
* cpt.Ljel-Api'process,

Member::
// Main
[NativeModule, _debugEnd, _debugPause, _debugProcess, _events, _eventsCount, _exiting, _fatalException, _getActiveHandles, _getActiveRequests, _kill, _linkedBinding, _maxListeners, _needImmediateCallback, _promiseRejectEvent, _rawDebug, _setupDomainUse, _startProfilerIdleNotifier, _stopProfilerIdleNotifier, _tickCallback, _tickDomainCallback, abort, activateUvLoop, arch, argv, argv0, assert, atomBinding, binding, chdir, config, cpuUsage, crash, cwd, debugPort, defaultApp, dlopen, domain, emitWarning, env, execArgv, execPath, exit, features, getCPUUsage, getIOCounters, getProcessMemoryInfo, getSystemMemoryInfo, hang, helperExecPath, hrtime, kill, log, mainModule, memoryUsage, moduleLoadList, nextTick, openStdin, pid, platform, reallyExit, release, resourcesPath, stderr, stdin, stdout, title, type, umask, uptime, version, versions]
// Renderer
[NativeModule, _debugEnd, _debugPause, _debugProcess, _events, _eventsCount, _exiting, _fatalException, _getActiveHandles, _getActiveRequests, _kill, _linkedBinding, _maxListeners, _needImmediateCallback, _noBrowserGlobals, _promiseRejectEvent, _rawDebug, _setupDomainUse, _startProfilerIdleNotifier, _stopProfilerIdleNotifier, _tickCallback, _tickDomainCallback, abort, activateUvLoop, arch, argv, argv0, assert, atomBinding, binding, chdir, config, cpuUsage, crash, cwd, debugPort, dlopen, domain, emitWarning, env, execArgv, execPath, exit, features, getCPUUsage, getIOCounters, getProcessMemoryInfo, getRenderProcessPreferences, getSystemMemoryInfo, hang, helperExecPath, hrtime, kill, log, mainModule, memoryUsage, moduleLoadList, nextTick, openStdin, pid, platform, reallyExit, release, resourcesPath, stderr, stdin, stdout, title, type, umask, uptime, version, versions]

Ljel-Api'global-object

description::
The-most-whole-object of a-Ljel-app.
There-are 2 global-objects.
One in the-main-process and one in the-renderer-process.
[HmnSgm.2017-10-22]

name::
* cpt.Electronjs'global-object,
* cpt.Ljel'global-object,
* cpt.Ljel'Most-whole-object,
* cpt.Ljel-Api'global-object,
* cpt.Ljel--global-object,
* cpt.Most-whole-object.Ljel,

Member.main-process::
//Ljel-1.6.11 from main.js
//console.log(Object.getOwnPropertyNames(global).sort())
[ 'Array', 'ArrayBuffer', 'Boolean', 'Buffer', 'ByteLengthQueuingStrategy', 'CountQueuingStrategy', 'DataView', 'Date', 'Error', 'EvalError', 'Float32Array', 'Float64Array', 'Function', 'GLOBAL', 'Infinity', 'Int16Array', 'Int32Array', 'Int8Array', 'Intl', 'JSON', 'Map', 'Math', 'NaN', 'Number', 'Object', 'Promise', 'Proxy', 'RangeError', 'ReadableStream', 'ReferenceError', 'Reflect', 'RegExp', 'Set', 'String', 'Symbol', 'SyntaxError', 'TypeError', 'URIError', 'Uint16Array', 'Uint32Array', 'Uint8Array', 'Uint8ClampedArray', 'WeakMap', 'WeakSet', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', 'eval', 'global', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'process', 'root', 'setImmediate', 'setInterval', 'setTimeout', 'undefined', 'unescape' ]

Member.render-process::
//from a-webpage
//Object.getOwnPropertyNames(global).sort().join(', ')
[$, $$, $0, $1, $2, $3, $4, $_, $x, AnalyserNode, AnimationEvent, AppBannerPromptResult, ApplicationCache, ApplicationCacheErrorEvent, Array, ArrayBuffer, Attr, Audio, AudioBuffer, AudioBufferSourceNode, AudioContext, AudioDestinationNode, AudioListener, AudioNode, AudioParam, AudioProcessingEvent, AudioScheduledSourceNode, BarProp, BaseAudioContext, BatteryManager, BeforeInstallPromptEvent, BeforeUnloadEvent, BiquadFilterNode, Blob, BlobEvent, Boolean, BroadcastChannel, Buffer, ByteLengthQueuingStrategy, CDATASection, CSS, CSSConditionRule, CSSFontFaceRule, CSSGroupingRule, CSSImportRule, CSSKeyframeRule, CSSKeyframesRule, CSSMediaRule, CSSNamespaceRule, CSSPageRule, CSSRule, CSSRuleList, CSSStyleDeclaration, CSSStyleRule, CSSStyleSheet, CSSSupportsRule, CSSViewportRule, Cache, CacheStorage, CanvasCaptureMediaStreamTrack, CanvasGradient, CanvasPattern, CanvasRenderingContext2D, ChannelMergerNode, ChannelSplitterNode, CharacterData, ClientRect, ClientRectList, ClipboardEvent, CloseEvent, Comment, CompositionEvent, ConstantSourceNode, ConvolverNode, CountQueuingStrategy, Credential, CredentialsContainer, Crypto, CryptoKey, CustomElementRegistry, CustomEvent, DOMError, DOMException, DOMImplementation, DOMParser, DOMStringList, DOMStringMap, DOMTokenList, DataTransfer, DataTransferItem, DataTransferItemList, DataView, Date, DelayNode, DeviceMotionEvent, DeviceOrientationEvent, Document, DocumentFragment, DocumentType, DragEvent, DynamicsCompressorNode, Element, Error, ErrorEvent, EvalError, Event, EventSource, EventTarget, FederatedCredential, File, FileList, FileReader, Float32Array, Float64Array, FocusEvent, FontFace, FontFaceSetLoadEvent, FormData, Function, GLOBAL, GainNode, Gamepad, GamepadButton, GamepadEvent, HTMLAllCollection, HTMLAnchorElement, HTMLAreaElement, HTMLAudioElement, HTMLBRElement, HTMLBaseElement, HTMLBodyElement, HTMLButtonElement, HTMLCanvasElement, HTMLCollection, HTMLContentElement, HTMLDListElement, HTMLDataListElement, HTMLDetailsElement, HTMLDialogElement, HTMLDirectoryElement, HTMLDivElement, HTMLDocument, HTMLElement, HTMLEmbedElement, HTMLFieldSetElement, HTMLFontElement, HTMLFormControlsCollection, HTMLFormElement, HTMLFrameElement, HTMLFrameSetElement, HTMLHRElement, HTMLHeadElement, HTMLHeadingElement, HTMLHtmlElement, HTMLIFrameElement, HTMLImageElement, HTMLInputElement, HTMLLIElement, HTMLLabelElement, HTMLLegendElement, HTMLLinkElement, HTMLMapElement, HTMLMarqueeElement, HTMLMediaElement, HTMLMenuElement, HTMLMetaElement, HTMLMeterElement, HTMLModElement, HTMLOListElement, HTMLObjectElement, HTMLOptGroupElement, HTMLOptionElement, HTMLOptionsCollection, HTMLOutputElement, HTMLParagraphElement, HTMLParamElement, HTMLPictureElement, HTMLPreElement, HTMLProgressElement, HTMLQuoteElement, HTMLScriptElement, HTMLSelectElement, HTMLShadowElement, HTMLSlotElement, HTMLSourceElement, HTMLSpanElement, HTMLStyleElement, HTMLTableCaptionElement, HTMLTableCellElement, HTMLTableColElement, HTMLTableElement, HTMLTableRowElement, HTMLTableSectionElement, HTMLTemplateElement, HTMLTextAreaElement, HTMLTitleElement, HTMLTrackElement, HTMLUListElement, HTMLUnknownElement, HTMLVideoElement, HashChangeEvent, Headers, History, IDBCursor, IDBCursorWithValue, IDBDatabase, IDBFactory, IDBIndex, IDBKeyRange, IDBObjectStore, IDBOpenDBRequest, IDBRequest, IDBTransaction, IDBVersionChangeEvent, IIRFilterNode, IdleDeadline, Image, ImageBitmap, ImageBitmapRenderingContext, ImageData, Infinity, InputDeviceCapabilities, Int16Array, Int32Array, Int8Array, IntersectionObserver, IntersectionObserverEntry, Intl, JSON, KeyboardEvent, Location, MIDIAccess, MIDIConnectionEvent, MIDIInput, MIDIInputMap, MIDIMessageEvent, MIDIOutput, MIDIOutputMap, MIDIPort, Map, Math, MediaDeviceInfo, MediaDevices, MediaElementAudioSourceNode, MediaEncryptedEvent, MediaError, MediaKeyMessageEvent, MediaKeySession, MediaKeyStatusMap, MediaKeySystemAccess, MediaKeys, MediaList, MediaQueryList, MediaQueryListEvent, MediaRecorder, MediaSource, MediaStream, MediaStreamAudioDestinationNode, MediaStreamAudioSourceNode, MediaStreamEvent, MediaStreamTrack, MediaStreamTrackEvent, MessageChannel, MessageEvent, MessagePort, MimeType, MimeTypeArray, MouseEvent, MutationEvent, MutationObserver, MutationRecord, NaN, NamedNodeMap, Navigator, Node, NodeFilter, NodeIterator, NodeList, Notification, Number, Object, OfflineAudioCompletionEvent, OfflineAudioContext, Option, OscillatorNode, PageTransitionEvent, PannerNode, PasswordCredential, Path2D, Performance, PerformanceEntry, PerformanceLongTaskTiming, PerformanceMark, PerformanceMeasure, PerformanceNavigation, PerformanceNavigationTiming, PerformanceObserver, PerformanceObserverEntryList, PerformanceResourceTiming, PerformanceTiming, PeriodicWave, PermissionStatus, Permissions, Plugin, PluginArray, PointerEvent, PopStateEvent, Presentation, PresentationAvailability, PresentationConnection, PresentationConnectionAvailableEvent, PresentationConnectionCloseEvent, PresentationRequest, ProcessingInstruction, ProgressEvent, Promise, PromiseRejectionEvent, Proxy, PushManager, PushSubscription, PushSubscriptionOptions, RTCCertificate, RTCDataChannel, RTCDataChannelEvent, RTCIceCandidate, RTCPeerConnection, RTCPeerConnectionIceEvent, RTCSessionDescription, RTCStatsReport, RadioNodeList, Range, RangeError, ReadableStream, ReferenceError, Reflect, RegExp, RemotePlayback, Request, Response, SVGAElement, SVGAngle, SVGAnimateElement, SVGAnimateMotionElement, SVGAnimateTransformElement, SVGAnimatedAngle, SVGAnimatedBoolean, SVGAnimatedEnumeration, SVGAnimatedInteger, SVGAnimatedLength, SVGAnimatedLengthList, SVGAnimatedNumber, SVGAnimatedNumberList, SVGAnimatedPreserveAspectRatio, SVGAnimatedRect, SVGAnimatedString, SVGAnimatedTransformList, SVGAnimationElement, SVGCircleElement, SVGClipPathElement, SVGComponentTransferFunctionElement, SVGDefsElement, SVGDescElement, SVGDiscardElement, SVGElement, SVGEllipseElement, SVGFEBlendElement, SVGFEColorMatrixElement, SVGFEComponentTransferElement, SVGFECompositeElement, SVGFEConvolveMatrixElement, SVGFEDiffuseLightingElement, SVGFEDisplacementMapElement, SVGFEDistantLightElement, SVGFEDropShadowElement, SVGFEFloodElement, SVGFEFuncAElement, SVGFEFuncBElement, SVGFEFuncGElement, SVGFEFuncRElement, SVGFEGaussianBlurElement, SVGFEImageElement, SVGFEMergeElement, SVGFEMergeNodeElement, SVGFEMorphologyElement, SVGFEOffsetElement, SVGFEPointLightElement, SVGFESpecularLightingElement, SVGFESpotLightElement, SVGFETileElement, SVGFETurbulenceElement, SVGFilterElement, SVGForeignObjectElement, SVGGElement, SVGGeometryElement, SVGGradientElement, SVGGraphicsElement, SVGImageElement, SVGLength, SVGLengthList, SVGLineElement, SVGLinearGradientElement, SVGMPathElement, SVGMarkerElement, SVGMaskElement, SVGMatrix, SVGMetadataElement, SVGNumber, SVGNumberList, SVGPathElement, SVGPatternElement, SVGPoint, SVGPointList, SVGPolygonElement, SVGPolylineElement, SVGPreserveAspectRatio, SVGRadialGradientElement, SVGRect, SVGRectElement, SVGSVGElement, SVGScriptElement, SVGSetElement, SVGStopElement, SVGStringList, SVGStyleElement, SVGSwitchElement, SVGSymbolElement, SVGTSpanElement, SVGTextContentElement, SVGTextElement, SVGTextPathElement, SVGTextPositioningElement, SVGTitleElement, SVGTransform, SVGTransformList, SVGUnitTypes, SVGUseElement, SVGViewElement, Screen, ScreenOrientation, ScriptProcessorNode, SecurityPolicyViolationEvent, Selection, ServiceWorker, ServiceWorkerContainer, ServiceWorkerRegistration, Set, ShadowRoot, SharedWorker, SiteBoundCredential, SourceBuffer, SourceBufferList, SpeechSynthesisEvent, SpeechSynthesisUtterance, StereoPannerNode, Storage, StorageEvent, StorageManager, String, StyleSheet, StyleSheetList, SubtleCrypto, Symbol, SyncManager, SyntaxError, TaskAttributionTiming, Text, TextDecoder, TextEncoder, TextEvent, TextMetrics, TextTrack, TextTrackCue, TextTrackCueList, TextTrackList, TimeRanges, Touch, TouchEvent, TouchList, TrackEvent, TransitionEvent, TreeWalker, TypeError, UIEvent, URIError, URL, URLSearchParams, Uint16Array, Uint32Array, Uint8Array, Uint8ClampedArray, VTTCue, ValidityState, WaveShaperNode, WeakMap, WeakSet, WebAssembly, WebGL2RenderingContext, WebGLActiveInfo, WebGLBuffer, WebGLContextEvent, WebGLFramebuffer, WebGLProgram, WebGLQuery, WebGLRenderbuffer, WebGLRenderingContext, WebGLSampler, WebGLShader, WebGLShaderPrecisionFormat, WebGLSync, WebGLTexture, WebGLTransformFeedback, WebGLUniformLocation, WebGLVertexArrayObject, WebKitAnimationEvent, WebKitCSSMatrix, WebKitMutationObserver, WebKitTransitionEvent, WebSocket, WebView, WheelEvent, Window, Worker, XMLDocument, XMLHttpRequest, XMLHttpRequestEventTarget, XMLHttpRequestUpload, XMLSerializer, XPathEvaluator, XPathExpression, XPathResult, XSLTProcessor, __dirname, __filename, alert, applicationCache, atob, blur, btoa, caches, cancelAnimationFrame, cancelIdleCallback, captureEvents, clear, clearImmediate, clearInterval, clearTimeout, clientInformation, close, closed, confirm, console, copy, createImageBitmap, crypto, customElements, debug, decodeURI, decodeURIComponent, defaultStatus, defaultstatus, devicePixelRatio, dir, dirxml, document, electron, encodeURI, encodeURIComponent, escape, eval, event, external, fetch, find, focus, frameElement, frames, getComputedStyle, getEventListeners, getMatchedCSSRules, getSelection, global, history, indexedDB, innerHeight, innerWidth, inspect, isFinite, isNaN, isSecureContext, keys, length, localStorage, location, locationbar, matchMedia, menubar, module, monitor, monitorEvents, moveBy, moveTo, name, navigator, offscreenBuffering, onabort, onanimationend, onanimationiteration, onanimationstart, onauxclick, onbeforeunload, onblur, oncancel, oncanplay, oncanplaythrough, onchange, onclick, onclose, oncontextmenu, oncuechange, ondblclick, ondevicemotion, ondeviceorientation, ondeviceorientationabsolute, ondrag, ondragend, ondragenter, ondragleave, ondragover, ondragstart, ondrop, ondurationchange, onemptied, onended, onerror, onfocus, ongotpointercapture, onhashchange, oninput, oninvalid, onkeydown, onkeypress, onkeyup, onlanguagechange, onload, onloadeddata, onloadedmetadata, onloadstart, onlostpointercapture, onmessage, onmousedown, onmouseenter, onmouseleave, onmousemove, onmouseout, onmouseover, onmouseup, onmousewheel, onoffline, ononline, onpagehide, onpageshow, onpause, onplay, onplaying, onpointercancel, onpointerdown, onpointerenter, onpointerleave, onpointermove, onpointerout, onpointerover, onpointerup, onpopstate, onprogress, onratechange, onrejectionhandled, onreset, onresize, onscroll, onsearch, onseeked, onseeking, onselect, onshow, onstalled, onstorage, onsubmit, onsuspend, ontimeupdate, ontoggle, ontransitionend, onunhandledrejection, onunload, onvolumechange, onwaiting, onwebkitanimationend, onwebkitanimationiteration, onwebkitanimationstart, onwebkittransitionend, onwheel, open, openDatabase, opener, outerHeight, outerWidth, pageXOffset, pageYOffset, parent, parseFloat, parseInt, performance, personalbar, postMessage, print, process, profile, profileEnd, prompt, releaseEvents, requestAnimationFrame, requestIdleCallback, require, resizeBy, resizeTo, root, screen, screenLeft, screenTop, screenX, screenY, scroll, scrollBy, scrollTo, scrollX, scrollY, scrollbars, self, sessionStorage, setImmediate, setInterval, setTimeout, speechSynthesis, status, statusbar, stop, styleMedia, table, toolbar, top, undebug, undefined, unescape, unmonitor, unmonitorEvents, values, webkitCancelAnimationFrame, webkitMediaStream, webkitRTCPeerConnection, webkitRequestAnimationFrame, webkitRequestFileSystem, webkitResolveLocalFileSystemURL, webkitSpeechGrammar, webkitSpeechGrammarList, webkitSpeechRecognition, webkitSpeechRecognitionError, webkitSpeechRecognitionEvent, webkitStorageInfo, webkitURL, window]

Generic::
* Javascript--most-whole-object,

Ljel-Api'Object.prototype

name::
* cpt.Ljel'Most-generic-object,
* cpt.Ljel'Object.prototype,
* cpt.Most-generic-object.Ljel,

Generic::
* Javascript--most-generic-object,

Ljel-Api'MAIN-PROCESS

description::
Main-process is the entry-point script of an-Electron-program.
It is package.json’s main script.
The-function of main-process is-related to GUI and low-level system managing.
[HmnSgm.2017-10-29]

name::
* cpt.Electronjs'main-process,
* cpt.Ljel'main-process,
* cpt.Ljel'process.main,
* cpt.Ljel-Api'process.browser, (typeof)
* cpt.Ljel-Api'process.main,

description::
Main-process is the entry-point script of an-Electron-program.
[HmnSgm.2017-07-11]
===
In Electron, the process that runs package.json’s main script is called the main process.
The script that runs in the main process can display a GUI by creating web pages.
[https://electron.atom.io/docs/tutorial/quick-start/#main-process]
===
The basic rule is: if a module is GUI or low-level system related, then it should be only available in the main process.
[https://github.com/electron/electron/blob/master/docs/api/synopsis.md]
===
The main process, commonly a file named main.js, is the entry point to every Electron app.
It controls the life of the app, from open to close.
It also manages native elements such as the Menu, Menu Bar, Dock, Tray, etc.
The main process is responsible for creating each new renderer process in the app.
The full Node API is built in.
Every app’s main process file is specified in the main property in package.json.
This is how electron . knows what file to execute at startup.
[https://electron.atom.io/docs/glossary/#main-process]

Ljel-Api'electron-object.main-process

name::
* cpt.Ljel'electron-object.main,
* cpt.Ljel-Api'electron-object,

Member::
//Electron-1.6.11
//console.log(Object.getOwnPropertyNames(electron).sort()) //on main.js
{BrowserView, BrowserWindow, Menu, MenuItem, TouchBar, Tray, app, autoUpdater, clipboard, contentTracing, crashReporter, dialog, globalShortcut, ipcMain, nativeImage, net, powerMonitor, powerSaveBlocker, protocol, screen, session, shell, systemPreferences, webContents}

Whole::
* Ljel--main-process,

Generic::
* Object.prototype,
//console.log(electron.__proto__ === Object.prototype) //true (on main.js)

Ljel-Api'BrowserView-function

description::
Create and control views.
Note: The BrowserView API is currently experimental and may change or be removed in future Electron releases.
Process: Main
A BrowserView can be used to embed additional web content into a BrowserWindow. It is like a child window, except that it is positioned relative to its owning window. It is meant to be an alternative to the webview tag.
[https://github.com/electron/electron/blob/master/docs/api/browser-view.md]

name::
* cpt.Ljel-Api'BrowserView-function,
* cpt.Ljel'BrowserView-function,

AddressWpg::
* {time.2017-01-29} Introducing BrowserView for Electron,

Ljel-Api'BrowserWindow-function

description::
A BrowserWindow object displays Html via its own renderer process.
===
Create and control browser windows.
Process: Main

// In the main process.
const {BrowserWindow} = require('electron')

// Or use `remote` from the renderer process.
// const {BrowserWindow} = require('electron').remote

let win = new BrowserWindow({width: 800, height: 600})
win.on('closed', () => {
 win = null
})

// Load a remote URL
win.loadURL('https://github.com')

// Or load a local HTML file
win.loadURL(`file://${__dirname}/app/index.html`)

[https://github.com/electron/electron/blob/master/docs/api/browser-window.md]

name::
* cpt.Ljel-Api'BrowserWindow-function,
* cpt.Ljel'BrowserWindow-function,
* cpt.Ljel-BrowserWindow-function,

Member::
// 1.7.9 console.log(Object.getOwnPropertyNames(electron.BrowserWindow).sort().join(', '))
[addDevToolsExtension, addExtension, arguments, caller, fromDevToolsWebContents, fromId, fromWebContents, getAllWindows, getDevToolsExtensions, getExtensions, getFocusedWindow, length, name, prototype, removeDevToolsExtension, removeExtension]

Ljel-Api'BrowserWindow-object

name::
* cpt.Ljel'BrowserWindow-object,
* cpt.Ljel'oBrowserWindow,

Member::
// 1.7.9 console.log(Object.getOwnPropertyNames(new electron.BrowserWindow()).sort().join(', '))
[_events, _eventsCount, devToolsWebContents]
// console.log(Object.getOwnPropertyNames(new electron.BrowserWindow().__proto__).sort().join(', '))
[_init, _refreshTouchBarItem, _setEscapeTouchBarItem, _setTouchBarItems, blur, blurWebView, capturePage, center, close, closeDevTools, closeFilePreview, constructor, destroy, flashFrame, focus, focusOnWebView, getBounds, getBrowserView, getChildWindows, getContentBounds, getContentSize, getMaximumSize, getMinimumSize, getNativeWindowHandle, getParentWindow, getPosition, getRepresentedFilename, getSize, getTitle, getURL, hasShadow, hide, hookWindowMessage, id, inspectElement, inspectServiceWorker, isAlwaysOnTop, isClosable, isDestroyed, isDevToolsFocused, isDevToolsOpened, isDocumentEdited, isEnabled, isFocused, isFullScreen, isFullScreenable, isKiosk, isMaximizable, isMaximized, isMenuBarAutoHide, isMenuBarVisible, isMinimizable, isMinimized, isModal, isMovable, isResizable, isVisible, isVisibleOnAllWorkspaces, isWebViewFocused, isWindowMessageHooked, loadURL, maximize, minimize, openDevTools, previewFile, reload, restore, send, setAlwaysOnTop, setAppDetails, setAspectRatio, setAutoHideMenuBar, setBackgroundColor, setBounds, setBrowserView, setClosable, setContentBounds, setContentProtection, setContentSize, setDocumentEdited, setFocusable, setFullScreen, setFullScreenable, setHasShadow, setIcon, setIgnoreMouseEvents, setKiosk, setMaximizable, setMaximumSize, setMenu, setMenuBarVisibility, setMinimizable, setMinimumSize, setMovable, setOverlayIcon, setPosition, setProgressBar, setRepresentedFilename, setResizable, setSheetOffset, setSize, setSkipTaskbar, setThumbarButtons, setThumbnailClip, setThumbnailToolTip, setTitle, setTouchBar, setVibrancy, setVisibleOnAllWorkspaces, show, showDefinitionForSelection, showInactive, toggleDevTools, unhookAllWindowMessages, unhookWindowMessage, unmaximize, webContents]
// console.log(Object.getOwnPropertyNames(new electron.BrowserWindow().__proto__.__proto__).sort().join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// console.log(Object.getOwnPropertyNames(new electron.BrowserWindow().__proto__.__proto__.__proto__).sort().join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'Menu-function

description::
Create native application menus and context menus.
[https://electron.atom.io/docs/api/menu/]

name::
* cpt.Ljel-Api'Menu-function,
* cpt.Ljel'fMenu,
* cpt.Ljel'Menu-function,

Member::
// main-process 1.7.9
// console.log(Object.getOwnPropertyNames(electron.Menu).sort().join(', '))
[arguments, buildFromTemplate, caller, getApplicationMenu, length, name, prototype, sendActionToFirstResponder, setApplicationMenu]

Ljel-Api'Menu-object

name::
* cpt.Ljel'oMenu,
* cpt.Ljel-Api'Menu-object,

Member::
// console.log(Object.getOwnPropertyNames(new electron.Menu()).sort().join(', '))
[commandsMap, delegate, groupsMap, items]
// console.log(Object.getOwnPropertyNames(new electron.Menu().__proto__).sort().join(', '))
[_callMenuWillShow, _init, append, clear, closePopup, closePopupAt, constructor, destroy, getCommandIdAt, getIndexOfCommandId, getItemCount, getLabelAt, getSublabelAt, insert, insertCheckItem, insertItem, insertRadioItem, insertSeparator, insertSubMenu, isDestroyed, isEnabledAt, isItemCheckedAt, isVisibleAt, popup, popupAt, setIcon, setRole, setSublabel
// console.log(Object.getOwnPropertyNames(new electron.Menu().__proto__.__proto__).sort().join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners
// console.log(Object.getOwnPropertyNames(new electron.Menu().__proto__.__proto__.__proto__).sort().join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf

Ljel-Api'MenuItem-function

description::
Add items to native application menus and context menus.
Process: Main
[https://electron.atom.io/docs/api/menu-item/]

name::
* cpt.Ljel-Api'MenuItem-function,
* cpt.Ljel'MenuItem-function,
* cpt.Ljel-MenuItem-function,

Ljel-Api'MenuItem-object

description::
new MenuItem(options)
options Object
- click Function (optional) - Will be called with click(menuItem, browserWindow, event) when the menu item is clicked.
-- menuItem MenuItem
-- browserWindow BrowserWindow
-- event Event
- role String (optional) - Define the action of the menu item, when specified the click property will be ignored. See roles.
- type String (optional) - Can be normal, separator, submenu, checkbox or radio.
- label String - (optional)
- sublabel String - (optional)
- accelerator Accelerator (optional)
- icon (NativeImage | String) (optional)
- enabled Boolean (optional) - If false, the menu item will be greyed out and unclickable.
- visible Boolean (optional) - If false, the menu item will be entirely hidden.
- checked Boolean (optional) - Should only be specified for checkbox or radio type menu items.
- submenu (MenuItemConstructorOptions[] | Menu) (optional) - Should be specified for submenu type menu items. If submenu is specified, the type: 'submenu' can be omitted. If the value is not a Menu then it will be automatically converted to one using Menu.buildFromTemplate.
- id String (optional) - Unique within a single menu. If defined then it can be used as a reference to this item by the position attribute.
- position String (optional) - This field allows fine-grained definition of the specific location within a given menu.
[https://electron.atom.io/docs/api/menu-item/#new-menuitemoptions]

name::
* cpt.Ljel'oMenuItem,
* cpt.Ljel-Api'MenuItem-object,

Member::
// 1.7.9 console.log(Object.getOwnPropertyNames(new electron.MenuItem({role: 'cut'})).sort().join(', '))
[accelerator, checked, click, commandId, enabled, icon, label, role, sublabel, submenu, type, visible]
// console.log(Object.getOwnPropertyNames(new electron.MenuItem({role: 'cut'}).__proto__).sort().join(', '))
[constructor, getDefaultRoleAccelerator, overrideProperty, overrideReadOnlyProperty]
// console.log(Object.getOwnPropertyNames(new electron.MenuItem({role: 'cut'}).__proto__.__proto__).sort().join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Example::
//submenu
{
label: 'Edit',
submenu: [ {mi-object}, {mio} ]
}

===
//Call external webpage
{
label: 'Learn More',
click () { require('electron').shell.openExternal('https://electron.atom.io') }
}

===
//Predefined menu-item
{role: 'close'}

===
//Separator menu-item
{type: 'separator'}

Ljel-Api'TouchBar-function

name::
* cpt.Ljel-Api'TouchBar-function,
* cpt.Ljel'TouchBar-function,
* cpt.Ljel-TouchBar-function,

Ljel-Api'Tray-function

name::
* cpt.Ljel-Api'Tray-function,
* cpt.Ljel'Tray-function,
* cpt.Ljel-Tray-function,

Ljel-Api'app-object

description::
Control your application's event lifecycle.
Process: Main
The following example shows how to quit the application when the last window is closed:
const {app} = require('electron')
app.on('window-all-closed', () => {
 app.quit()
})

[https://github.com/electron/electron/blob/master/docs/api/app.md]

name::
* cpt.Ljel-Api'app-object,
* cpt.Ljel'app-object,
* cpt.Ljel-app-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.app).sort()).join(', '))
[_events, _eventsCount, allowNTLMCredentialsForAllDomains, commandLine, getApplicationMenu, setApplicationMenu]
// Object.getOwnPropertyNames(electron.app.__proto__).sort()).join(', '))
[addRecentDocument, clearRecentDocuments, constructor, disableDomainBlockingFor3DAPIs, disableHardwareAcceleration, enableMixedSandbox, exit, focus, getAppMemoryInfo, getAppMetrics, getAppPath, getBadgeCount, getFileIcon, getGPUFeatureStatus, getJumpListSettings, getLocale, getLoginItemSettings, getName, getPath, getVersion, isAccessibilitySupportEnabled, isDefaultProtocolClient, isReady, makeSingleInstance, quit, relaunch, releaseSingleInstance, removeAsDefaultProtocolClient, setAppPath, setAppUserModelId, setAsDefaultProtocolClient, setBadgeCount, setDesktopName, setJumpList, setLoginItemSettings, setName, setPath, setUserTasks, setVersion]
// Object.getOwnPropertyNames(electron.app.__proto__.__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(electron.app.__proto__.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'autoUpdater-object

description::
Enable apps to automatically update themselves.
Process: Main
[https://github.com/electron/electron/blob/master/docs/api/auto-updater.md]

name::
* cpt.Ljel-Api'autoUpdater-object,
* cpt.Ljel'autoUpdater-object,
* cpt.Ljel-autoUpdater-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.autoUpdater).sort()).join(', '))
[_events, _eventsCount, _maxListeners, domain]
// Object.getOwnPropertyNames(electron.autoUpdater.__proto__).sort()).join(', '))
[checkForUpdates, constructor, emitError, getFeedURL, quitAndInstall, setFeedURL]
// Object.getOwnPropertyNames(electron.autoUpdater.__proto__.__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(electron.autoUpdater.__proto__.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'clipboard-object

description::
Perform copy and paste operations on the system clipboard.
Process: Main, Renderer
[https://github.com/electron/electron/blob/master/docs/api/clipboard.md]

name::
* cpt.Ljel-Api'clipboard-object,
* cpt.Ljel'clipboard-object,
* cpt.Ljel-clipboard-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.clipboard).sort()).join(', '))
[availableFormats, clear, has, read, readBookmark, readBuffer, readFindText, readHTML, readHtml, readImage, readRTF, readRtf, readText, write, writeBookmark, writeBuffer, writeFindText, writeHTML, writeHtml, writeImage, writeRTF, writeRtf, writeText]
// Object.getOwnPropertyNames(electron.clipboard.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'contentTracing-object

description::
Collect tracing data from Chromium's content module for finding performance bottlenecks and slow operations.
Process: Main
This module does not include a web interface so you need to open chrome://tracing/ in a Chrome browser and load the generated file to view the result.
Note: You should not use this module until the ready event of the app module is emitted.
[https://github.com/electron/electron/blob/master/docs/api/content-tracing.md]

name::
* cpt.Ljel-Api'contentTracing-object,
* cpt.Ljel'contentTracing-object,
* cpt.Ljel-contentTracing-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.contentTracing).sort()).join(', '))
[getCategories, getTraceBufferUsage, startRecording, stopRecording]
// Object.getOwnPropertyNames(electron.contentTracing.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'crashReporter-object

description::
Submit crash reports to a remote server.
Process: Main, Renderer
[https://github.com/electron/electron/blob/master/docs/api/crash-reporter.md]

name::
* cpt.Ljel-Api'crashReporter-object,
* cpt.Ljel'crashReporter-object,
* cpt.Ljel-crashReporter-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.crashReporter).sort()).join(', '))
[]
// Object.getOwnPropertyNames(electron.crashReporter.__proto__).sort()).join(', '))
[constructor, getCrashesDirectory, getLastCrashReport, getProductName, getTempDirectory, getUploadToServer, getUploadedReports, setExtraParameter, setUploadToServer, start]
// Object.getOwnPropertyNames(electron.crashReporter.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'dialog-object

description::
Display native system dialogs for opening and saving files, alerting, etc.
Process: Main
An example of showing a dialog to select multiple files and directories:
const {dialog} = require('electron')
console.log(dialog.showOpenDialog({properties: ['openFile', 'openDirectory', 'multiSelections']}))

The Dialog is opened from Electron's main thread. If you want to use the dialog object from a renderer process, remember to access it using the remote:
const {dialog} = require('electron').remote
console.log(dialog)

[https://github.com/electron/electron/blob/master/docs/api/dialog.md]

name::
* cpt.Ljel-Api'dialog-object,
* cpt.Ljel'dialog-object,
* cpt.Ljel-dialog-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.dialog).sort()).join(', '))
[showCertificateTrustDialog, showErrorBox, showMessageBox, showOpenDialog, showSaveDialog]
// Object.getOwnPropertyNames(electron.dialog.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'dialog.showOpenDialog-function

description::
Official doc: https://github.com/electron/electron/blob/master/docs/api/dialog.md#dialogshowopendialogbrowserwindow-options-callback,

Example::


    // opens a-file and displays it
    click () { electron.dialog.showOpenDialog(
        {
          defaultPath: sDirMiw,
          properties: ['openFile']
        },
        function(aFilenames) {
          oBrowserWindow.loadURL(aFilenames[0])
        }
      )
    }
    

Ljel-Api'globalShortcut-object

description::
Detect keyboard events when the application does not have keyboard focus.
Process: Main
The globalShortcut module can register/unregister a global keyboard shortcut with the operating system so that you can customize the operations for various shortcuts.
Note: The shortcut is global; it will work even if the app does not have the keyboard focus. You should not use this module until the ready event of the app module is emitted.
[https://github.com/electron/electron/blob/master/docs/api/global-shortcut.md]

name::
* cpt.Ljel-Api'globalShortcut-object,
* cpt.Ljel'globalShortcut-object,
* cpt.Ljel-globalShortcut-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.globalShortcut).sort()).join(', '))
[]
// Object.getOwnPropertyNames(electron.globalShortcut.__proto__).sort()).join(', '))
[constructor, isRegistered, register, unregister, unregisterAll]
// Object.getOwnPropertyNames(electron.globalShortcut.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'ipcMain-object

description::
Communicate asynchronously from the main process to renderer processes.
Process: Main
The ipcMain module is an instance of the EventEmitter class. When used in the main process, it handles asynchronous and synchronous messages sent from a renderer process (web page). Messages sent from a renderer will be emitted to this module.
[https://github.com/electron/electron/blob/master/docs/api/ipc-main.md]

name::
* cpt.Ljel-Api'ipcMain-object,
* cpt.Ljel'ipcMain-object,
* cpt.Ljel-ipcMain-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.ipcMain).sort()).join(', '))
[_events, _eventsCount, _maxListeners, domain, removeAllListeners]
// Object.getOwnPropertyNames(electron.ipcMain.__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(electron.ipcMain.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'nativeImage-object

description::
Create tray, dock, and application icons using PNG or JPG files.
Process: Main, Renderer
In Electron, for the APIs that take images, you can pass either file paths or NativeImage instances. An empty image will be used when null is passed.
[https://github.com/electron/electron/blob/master/docs/api/native-image.md]

name::
* cpt.Ljel-Api'nativeImage-object,
* cpt.Ljel'nativeImage-object,
* cpt.Ljel-nativeImage-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.nativeImage).sort()).join(', '))
[createEmpty, createFromBuffer, createFromDataURL, createFromPath]
// Object.getOwnPropertyNames(electron.nativeImage.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'net-object

description::
Issue HTTP/HTTPS requests using Chromium's native networking library
Process: Main
The net module is a client-side API for issuing HTTP(S) requests. It is similar to the HTTP and HTTPS modules of Node.js but uses Chromium's native networking library instead of the Node.js implementation, offering better support for web proxies.
The following is a non-exhaustive list of why you may consider using the net module instead of the native Node.js modules:
Automatic management of system proxy configuration, support of the wpad protocol and proxy pac configuration files.
Automatic tunneling of HTTPS requests.
Support for authenticating proxies using basic, digest, NTLM, Kerberos or negotiate authentication schemes.
Support for traffic monitoring proxies: Fiddler-like proxies used for access control and monitoring.
The net module API has been specifically designed to mimic, as closely as possible, the familiar Node.js API. The API components including classes, methods, properties and event names are similar to those commonly used in Node.js.
[https://github.com/electron/electron/blob/master/docs/api/net.md]

name::
* cpt.Ljel-Api'net-object,
* cpt.Ljel'net-object,
* cpt.Ljel-net-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.net).sort()).join(', '))
[ClientRequest]
// Object.getOwnPropertyNames(electron.net.__proto__).sort()).join(', '))
[URLRequest, constructor, request]
// Object.getOwnPropertyNames(electron.net.__proto__.__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(electron.net.__proto__.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'powerMonitor-object

description::
Monitor power state changes.
Process: Main
You cannot require or use this module until the ready event of the app module is emitted.
[https://github.com/electron/electron/blob/master/docs/api/power-monitor.md]

name::
* cpt.Ljel-Api'powerMonitor-object,
* cpt.Ljel'powerMonitor-object,
* cpt.Ljel-powerMonitor-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.powerMonitor).sort()).join(', '))
[]
// Object.getOwnPropertyNames(electron.powerMonitor.__proto__).sort()).join(', '))
[constructor]
// Object.getOwnPropertyNames(electron.powerMonitor.__proto__.__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(electron.powerMonitor.__proto__.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'powerSaveBlocker-object

description::
Block the system from entering low-power (sleep) mode.
Process: Main
[https://github.com/electron/electron/blob/master/docs/api/power-save-blocker.md]

name::
* cpt.Ljel-Api'powerSaveBlocker-object,
* cpt.Ljel'powerSaveBlocker-object,
* cpt.Ljel-powerSaveBlocker-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.powerSaveBlocker).sort()).join(', '))
[]
// Object.getOwnPropertyNames(electron.powerSaveBlocker.__proto__).sort()).join(', '))
[constructor, isStarted, start, stop]
// Object.getOwnPropertyNames(electron.powerSaveBlocker.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'protocol-object

description::
Register a custom protocol and intercept existing protocol requests.
Process: Main
[https://github.com/electron/electron/blob/master/docs/api/protocol.md]

name::
* cpt.Ljel-Api'protocol-object,
* cpt.Ljel'protocol-object,
* cpt.Ljel-protocol-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.protocol).sort()).join(', '))
[getStandardSchemes, registerStandardSchemes]

Ljel-Api'screen-object

description::
Retrieve information about screen size, displays, cursor position, etc.
Process: Main, Renderer
You cannot require or use this module until the ready event of the app module is emitted.
screen is an EventEmitter.
Note: In the renderer / DevTools, window.screen is a reserved DOM property, so writing let {screen} = require('electron') will not work.
An example of creating a window that fills the whole screen:

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

let win

app.on('ready', () => {
 const {width, height} = electron.screen.getPrimaryDisplay().workAreaSize
 win = new BrowserWindow({width, height})
 win.loadURL('https://github.com')
})

[https://github.com/electron/electron/blob/master/docs/api/screen.md]

name::
* cpt.Ljel-Api'screen-object,
* cpt.Ljel'screen-object,
* cpt.Ljel-screen-object,

Member::
// console.log(Object.getOwnPropertyNames(electron.screen).sort().join(', '))
[]
// console.log(Object.getOwnPropertyNames(electron.screen.__proto__).sort().join(', '))
[constructor, getAllDisplays, getCursorScreenPoint, getDisplayMatching, getDisplayNearestPoint, getPrimaryDisplay]
// console.log(Object.getOwnPropertyNames(electron.screen.__proto__.__proto__).sort().join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// console.log(Object.getOwnPropertyNames(electron.screen.__proto__.__proto__.__proto__).sort().join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'session-object

description::
Manage browser sessions, cookies, cache, proxy settings, etc.
Process: Main
The session module can be used to create new Session objects.
You can also access the session of existing pages by using the session property of WebContents, or from the session module.
[https://github.com/electron/electron/blob/master/docs/api/session.md]

name::
* cpt.Ljel-Api'session-object,
* cpt.Ljel'session-object,
* cpt.Ljel-session-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.session).sort()).join(', '))
[defaultSession, fromPartition]
// Object.getOwnPropertyNames(electron.session.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'shell-object

description::
Manage files and URLs using their default applications.
Process: Main, Renderer
The shell module provides functions related to desktop integration.
An example of opening a URL in the user's default browser:
const {shell} = require('electron')
shell.openExternal('https://github.com')

[https://github.com/electron/electron/blob/master/docs/api/shell.md]

name::
* cpt.Ljel-Api'shell-object,
* cpt.Ljel'shell-object,
* cpt.Ljel-shell-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.shell).sort()).join(', '))
[beep, moveItemToTrash, openExternal, openItem, readShortcutLink, showItemInFolder, writeShortcutLink]
// Object.getOwnPropertyNames(electron.shell.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'systemPreferences-object

description::
Get system preferences.
Process: Main

const {systemPreferences} = require('electron')
console.log(systemPreferences.isDarkMode())

[https://github.com/electron/electron/blob/master/docs/api/system-preferences.md]

name::
* cpt.Ljel-Api'systemPreferences-object,
* cpt.Ljel'systemPreferences-object,
* cpt.Ljel-systemPreferences-object,

Member::
// v1.7.9
// console.log(Object.getOwnPropertyNames(electron.systemPreferences).sort().join(', '))
[]
// console.log(Object.getOwnPropertyNames(electron.systemPreferences.__proto__).sort().join(', '))
constructor, getAccentColor, getColor, isAeroGlassEnabled, isDarkMode, isInvertedColorScheme]
// console.log(Object.getOwnPropertyNames(electron.systemPreferences.__proto__.__proto__).sort().join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// console.log(Object.getOwnPropertyNames(electron.systemPreferences.__proto__.__proto__.__proto__).sort().join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'webContents-object

description::
Render and control web pages.
Process: Main
webContents is an EventEmitter. It is responsible for rendering and controlling a web page and is a property of the BrowserWindow object. An example of accessing the webContents object:

const {BrowserWindow} = require('electron')

let win = new BrowserWindow({width: 800, height: 1500})
win.loadURL('http://github.com')

let contents = win.webContents
console.log(contents)

[https://github.com/electron/electron/blob/master/docs/api/web-contents.md]

name::
* cpt.Ljel-Api'webContents-object,
* cpt.Ljel'webContents-object,
* cpt.Ljel-webContents-object,

Member::
// 1.7.9 Object.getOwnPropertyNames(electron.webContents).sort()).join(', '))
[create, fromId, getAllWebContents, getFocusedWebContents]
// Object.getOwnPropertyNames(electron.webContents.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'RENDERER-PROCESS

description::
Renderer-process is the-process of the-scripts loaded in index.html-file.
[HmnSgm.2017-10-23]
===
Since Electron uses Chromium for displaying web pages, Chromium’s multi-process architecture is also used.
Each web page in Electron runs in its own process, which is called the renderer process.
In normal browsers, web pages usually run in a sandboxed environment and are not allowed access to native resources.
Electron users, however, have the power to use Node.js APIs in web pages allowing lower level operating system interactions.
[https://electron.atom.io/docs/tutorial/quick-start/#renderer-process]

name::
* cpt.Electronjs'renderer-process,
* cpt.Ljel'render-process, [https://electron.atom.io/docs/api/menu/#render-process]
* cpt.Ljel'renderer-process,
* cpt.Ljel'process.renderer,
* cpt.Ljel-Api'process.renderer,

Ljel-Api'electron-object.render

name::
* cpt.Ljel'electron-object.render,
* cpt.Ljel-Api'electron-object.render,

Member::
// Object.getOwnPropertyNames(electron).sort().join(', ')
// From webpage with require('electron')
[CallbacksRegistry, clipboard, crashReporter, deprecate, deprecations, desktopCapturer, ipcRenderer, isPromise, nativeImage, remote, screen, shell, webFrame]

Ljel-Api'desktopCapturer-object

description::
Access information about media sources that can be used to capture audio and video from the desktop using the navigator.mediaDevices.getUserMedia API.
[https://electron.atom.io/docs/api/desktop-capturer/]

name::
* cpt.Ljel-Api'desktopCapturer,

Ljel-Api'ipcRenderer-object

description::
Communicate asynchronously from a renderer process to the main process.
Process: Renderer
The ipcRenderer module is an instance of the EventEmitter class. It provides a few methods so you can send synchronous and asynchronous messages from the render process (web page) to the main process. You can also receive replies from the main process.
[https://electron.atom.io/docs/api/ipc-renderer/]

name::
* cpt.Ljel-Api'ipcRenderer,

Member::
// Object.getOwnPropertyNames(electron.ipcRenderer).sort().join(', ')
"_events, _eventsCount, _maxListeners, domain, removeAllListeners, send, sendSync, sendTo, sendToAll, sendToHost"
// Object.getOwnPropertyNames(electron.ipcRenderer.__proto__).sort().join(', ')
"_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners"
// Object.getOwnPropertyNames(electron.ipcRenderer.__proto__.__proto__).sort().join(', ')
"__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf"

Ljel-Api'remote-object

description::
Use main process modules from the renderer process.
Process: Renderer
The remote module provides a simple way to do inter-process communication (IPC) between the renderer process (web page) and the main process.
In Electron, GUI-related modules (such as dialog, menu etc.) are only available in the main process, not in the renderer process. In order to use them from the renderer process, the ipc module is necessary to send inter-process messages to the main process. With the remote module, you can invoke methods of the main process object without explicitly sending inter-process messages, similar to Java’s RMI. An example of creating a browser window from a renderer process:
const {BrowserWindow} = require('electron').remote
let win = new BrowserWindow({width: 800, height: 600})
win.loadURL('https://github.com')

[https://electron.atom.io/docs/api/remote/]

name::
* cpt.Ljel-Api'remote,

Member::
// Object.getOwnPropertyNames(electron.remote).sort().join(', ')
[BrowserView, BrowserWindow, Menu, MenuItem, Notification, TouchBar, Tray, app, autoUpdater, clipboard, contentTracing, crashReporter, createFunctionWithReturnValue, dialog, getBuiltin, getCurrentWebContents, getCurrentWindow, getGlobal, getGuestWebContents, globalShortcut, ipcMain, nativeImage, net, powerMonitor, powerSaveBlocker, process, protocol, require, screen, session, shell, systemPreferences, webContents]
// Object.getOwnPropertyNames(electron.remote.__proto__).sort().join(', ')
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]

Ljel-Api'webFrame-object

description::
Customize the rendering of the current web page.
[https://electron.atom.io/docs/api/web-frame/]

name::
* cpt.Ljel-Api'webFrame,

Member::
// Object.getOwnPropertyNames(electron.webFrame).sort().join(', ')
[_maxListeners]
===
// Object.getOwnPropertyNames(electron.webFrame.__proto__).sort().join(', ')
[attachGuest, clearCache, constructor, detachGuest, executeJavaScript, getResourceUsage, getZoomFactor, getZoomLevel, insertCSS, insertText, registerElementResizeCallback, registerEmbedderCustomElement, registerURLSchemeAsBypassingCSP, registerURLSchemeAsPrivileged, registerURLSchemeAsSecure, setLayoutZoomLevelLimits, setName, setSpellCheckProvider, setVisualZoomLevelLimits, setZoomFactor, setZoomLevel, setZoomLevelLimits]
===
// Object.getOwnPropertyNames(electron.webFrame.__proto__.__proto__).sort().join(', ')
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]

Ljel-doc.PROGRAM (application)

name::
* cpt.Electronjs'application-(Ljel-pgm),
* cpt.Electronjs'program-(Ljel-pgm),
* cpt.Ljel'app,
* cpt.Ljel'pgm,
* cpt.Ljel'program,
* cpt.Ljel-algo.program-(Ljel-pgm),
* cpt.Ljel-application-(Ljel-pgm),
* cpt.Ljel-pgm,
* cpt.Ljel-pgm-(Electron-program),
* cpt.Ljel-program-(Ljel-pgm),
* cpt.program.Electron-(Ljel-pgm),

Generic::
* Javascript-program,

main.js-file--of--Ljel-pgm

description::
The-main.js-file contains the-script of the-main-process.
[HmnSgm.2017-10-28]

name::
* cpt.Ljel'main.js,
* cpt.Ljel-pgm'main.js,

renderer.html-file--of--Ljel-pgm

description::
The-renderer.html-file contains the-script of the-renderer-process.
[HmnSgm.2017-10-28]

name::
* cpt.Ljel'renderer.html-file,
* cpt.Ljel-pgm'index.html,
* cpt.Ljel-pgm'render.html-file,

description::
Finally the index.html is the web page you want to show:


<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Hello World!</title>
  </head>
  <body>
    <h1>Hello World!</h1>
    We are using node <script>document.write(process.versions.node)</script>,
    Chrome <script>document.write(process.versions.chrome)</script>,
    and Electron <script>document.write(process.versions.electron)</script>.
  </body>
</html>
    

package.json-file--of--Ljel-pgm

description::
The format of package.json is exactly the same as that of Node’s modules, and the script specified by the main field is the startup script of your app, which will run the main process. An example of your package.json might look like this:
{
 "name" : "your-app",
 "version" : "0.1.0",
 "main" : "main.js"
}

Note: If the main field is not present in package.json, Electron will attempt to load an index.js.
[https://electron.atom.io/docs/tutorial/quick-start/#write-your-first-electron-app]

name::
* cpt.Ljel'file.package.json-of-app,
* cpt.Ljel'package.json-of-app,
* cpt.Ljel-package.json,
* cpt.Ljel-pgm'package.json,
* cpt.package.json-of-Electronjs,

Generic::
* Ljn-package.json,

Ljel-package.json'name-string-member

description::
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.
[https://github.com/electron/electron/blob/master/docs/api/app.md#appgetname]

name::
* cpt.Ljel-package.json'name-string-member,
* cpt.Ljel-package.json'productName-string-member,

structure-of--Ljel-pgm

description::
Generally, an Electron app is structured like this:
your-app/
   |-- package.json
   |-- main.js
   |-- index.html

[https://electron.atom.io/docs/tutorial/quick-start/#write-your-first-electron-app]

name::
* cpt.Ljel-pgm'structure,

Installing--Ljel-pgm

description::

name::
* cpt.Ljel'installing-app,
* cpt.Ljel-pgm'installing,

Using--Ljel-pgm

description::
* 1st case:
· from program's directory, type: electron .
===
* 2nd case:
· if package.json contains a start script, type: npm run start

name::
* cpt.Ljel'using-app,
* cpt.Ljel-pgm'running,
* cpt.Ljel-pgm'using,

testing--Ljel-pgm

name::
* cpt.Ljel'testing-app,
* cpt.Ljel-pgm'testing,

Specific::
* https://github.com/jprichardson/electron-mocha,
* https://github.com/electron/spectron,

debugging--Ljel-pgm

name::
* cpt.Ljel'debugging-app,
* cpt.Ljel-pgm'Debugging,

AddressWpg::
* https://www.sitepoint.com/debugging-electron-application/,
* https://www.tutorialspoint.com/electron/electron_debugging.htm,

packaging--Ljel-pgm

name::
* cpt.Ljel'packeging-app,
* cpt.Ljel-pgm'packeging,

Specific::
* Electron-builder: https://github.com/electron-userland/electron-builder,
* Electron-forge: https://github.com/electron-userland/electron-forge,
* Electron-packager: https://github.com/electron-userland/electron-packager,

Auto-updating--Ljel-pgm

name::
* cpt.Ljel-pgm'auto-updating,

AddressWpg::
* Auto-updating apps for Windows and OSX using Electron: The complete guide: https://medium.com/heresy-dev/,

Ljel-pgm.SPECIFIC

name::
* cpt.Ljel-pgm.specific,

Specific::
* https://electron.atom.io/apps/,
* Atom-editor,
* Visual-Studio-Code--editor,

Ljel-pgm.Visual-Studio-Code (vscode)

description::
VS Code is a new type of tool that combines the simplicity of a code editor with what developers need for their core edit-build-debug cycle.
Code provides comprehensive editing and debugging support, an extensibility model, and lightweight integration with existing tools.
VS Code is updated monthly with new features and bug fixes.
[https://github.com/microsoft/vscode]

name::
* cpt.Ljel-pgm.Visual-Studio-Code,
* cpt.Ljel'Visual-Studio-Code,
* cpt.Visual-Studio-Code,
* cpt.Visual-Studio-Code.Ljel-pgm,
* cpt.VSCode.Ljel-pgm,

AddressWpg::
* code.visualstudio.com: https://code.visualstudio.com/,
* GitHub: https://github.com/microsoft/vscode,
===
* stackoverflow: https://stackoverflow.com/questions/tagged/visual-studio-code,

tool-of-Ljel

name::
* cpt.Ljel-tool,

Specific::
* Runtime,
* Debugger,
* Packager,
* Test-tool,

Ljel-tool.RUNTIME (Ljel-rt)

description::
Electron is a runtime, just like node.
This means instead of running node app.js you run electron app.js.
===
Electron is a JavaScript runtime that bundles Node.js and Chromium.
You use it similar to the node command on the command line for executing JavaScript programs.
[https://github.com/electron-userland/electron-prebuilt]

name::
* cpt.Electronjs'runtime-(Ljel-rt),
* cpt.Ljel'runtime,
* cpt.Ljel-rt-(Ljel-runtime),
* cpt.Ljel-runtime-(Ljel-rt),
* cpt.Ljel-tool.runtime,

AddressWpg::
* https://electronjs.org/releases,

human-of-Ljel

name::
* cpt.Ljel-hmn-(Electron-js-human),
* cpt.Ljel-human,

Specific::
* Zhao.Cheng,

Ljel-hmn.Zhao.Cheng

description::
Electron is an open source project written by Cheng Zhao AKA zcbenz, an engineer who works for GitHub in Beijing on the Atom text editor team.
It combines Chromium and Node into a single runtime suitable for building custom desktop web applications that also have access to Node for things that web browsers normally can't do. [https://maxogden.com/electron-fundamentals.html]

name::
* cpt.Cheng-Zhao-human,
* cpt.human.Zhao.Cheng,
* cpt.Ljel-human.Zhao.Cheng,
* cpt.zcbenz-(Zhao.Cheng-human),
* cpt.Zhao.Cheng-human,

AddressWpg::
* https://github.com/zcbenz,

relation-Ljel-to-NW.js

description::
Electron is conceptually similar to nw.js but has some important technical differences which are explained here.
A key difference is that Electron uses Googles Chromium Content Module to bring in Chromium functionality vs nw.js which uses a forked version of Chromium itself. [https://maxogden.com/electron-fundamentals.html]

name::
* cpt.Electronjs-relation-to-NW.js,
* cpt.Ljel-relation-to-NW.js,
* cpt.NW.js-relation-to-Electron,

AddressWpg::
* Technical Differences Between Electron and NW.js: https://github.com/electron/electron/,

resource-of-Ljel

name::
* cpt.Electronjs'resource,
* cpt.Ljel'resource,

AddressWpg::
* https://electron.atom.io/,
* https://github.com/electron/electron,
=== USERS::
* https://twitter.com/electronjs,
* https://electron.atom.io/blog/,
* https://electron.atom.io/userland/,
* https://discuss.atom.io/c/electron,
=== DOCS::
* https://electron.atom.io/docs/,
===
* https://github.com/sindresorhus/awesome-electron,
* https://blog.dcpos.ch/how-to-make-your-electron-app-sexy,

GENERIC-CHAIN--of-Ljel

Generic::
* Desktop-javascript-language,

Ljel.SPECIFIC

name::
* cpt.Ljel.specific,

AddressWpg::
* https://electron.atom.io/releases/,

Ljel.EVOLUTING

name::
* cpt.Electronjs.evoluting,
* cpt.Ljel'history,
* cpt.Ljel.evoluting,

{time.2016-08}::
=== August 2016 Windows Store support for Electron apps.
[https://electron.atom.io/docs/tutorial/about/#history]

{time.2016-05}::
=== May 2016 Electron releases v1.0.0, Electron apps compatible with Mac App Store.

{time.2015-04}::
=== April 2015 Atom Shell is re-named Electron.

{time.2014-05}::
=== May 2014 Atom Shell is open sourced.

{time.2013-04}::
=== April 2013 Atom Shell is started.

Meta-Info

This page was-visited times since {2017-07-11}

page-wholepath: synagonism.net / Mcs-worldview / dirTechInfo / Electron-Desktop-Javascript (Ljel)

SEARCH::
This page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
LOCAL-SEARCH:
Type CTRL+F "cpt.words-of-concept's-name", to go to the-LOCATION of the-concept.
GLOBAL-SEARCH:
Clicking on the-green-TITLE of a-page you have access to the-global--locator-names of my-site.
A-preview of the-description of a-global-name makes reading fast.
Abbreviations have no description.

Footer::
• author: Kaseluris.Nikos.1959
• email:
 imgMail
• twitter: @synagonism

Webpage-Versions::
• version.last.dynamic: filMcsLjel.last.html,
• version.4-0-0.2017-11-26.last: FilMcsLjel.4-0-0.2017-11-26.html,
• version.0-1-0.2017-07-11.created: filMcsLjel.0-1-0.2017-07-11.html,

Support (Link)

Comments (Link)