mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Merge pull request #2093 from preco21/master

Browse source 
Translate docs into korean #2 + added link of power-save-blocker API to README
This commit is contained in:
Cheng Zhao 2015-07-05 21:21:56 +08:00
commit 4e94e0c82f
50 changed files with 4034 additions and 218 deletions
Download patch file Download diff file Expand all files Collapse all files

2
docs/api/accelerator-ko.md
View file

@ -1,4 +1,4 @@
# Accelerator
# Accelerator
Accelerator는 키보드 단축키를 표현하는 문자열입니다, 여러 혼합키와 키코드를 `+` 문자를
이용하여 결합할 수 있습니다.

317
docs/api/app-ko.md Normal file
View file

@ -0,0 +1,317 @@
# app
The `app` module is responsible for controlling the application's life time.
The example of quitting the whole application when the last window is closed:
```javascript
var app = require('app');
app.on('window-all-closed', function() {
app.quit();
});
```
## Event: will-finish-launching
Emitted when application has done basic startup. On Windows and Linux it is the
same with `ready` event, on OS X this event represents the
`applicationWillFinishLaunching` message of `NSApplication`, usually you would
setup listeners to `open-file` and `open-url` events here, and start the crash
reporter and auto updater.
Under most cases you should just do everything in `ready` event.
## Event: ready
Emitted when Electron has done everything initialization.
## Event: window-all-closed
Emitted when all windows have been closed.
This event is only emitted when the application is not going to quit. If a
user pressed `Cmd + Q`, or the developer called `app.quit()`, Electron would
first try to close all windows and then emit the `will-quit` event, and in
this case the `window-all-closed` would not be emitted.
## Event: before-quit
* `event` Event
Emitted before the application starts closing its windows.
Calling `event.preventDefault()` will prevent the default behaviour, which is
terminating the application.
## Event: will-quit
* `event` Event
Emitted when all windows have been closed and the application will quit.
Calling `event.preventDefault()` will prevent the default behaviour, which is
terminating the application.
See description of `window-all-closed` for the differences between `will-quit`
and it.
## Event: quit
Emitted when application is quitting.
## Event: open-file
* `event` Event
* `path` String
Emitted when user wants to open a file with the application, it usually happens
when the application is already opened and then OS wants to reuse the
application to open file. But it is also emitted when a file is dropped onto the
dock and the application is not yet running. Make sure to listen to open-file
very early in your application startup to handle this case (even before the
`ready` event is emitted).
You should call `event.preventDefault()` if you want to handle this event.
## Event: open-url
* `event` Event
* `url` String
Emitted when user wants to open a URL with the application, this URL scheme
must be registered to be opened by your application.
You should call `event.preventDefault()` if you want to handle this event.
## Event: activate-with-no-open-windows
Emitted when the application is activated while there is no opened windows. It
usually happens when user has closed all of application's windows and then
click on the application's dock icon.
## Event: browser-window-blur
* `event` Event
* `window` BrowserWindow
Emitted when a [browserWindow](browser-window-ko.md) gets blurred.
## Event: browser-window-focus
* `event` Event
* `window` BrowserWindow
Emitted when a [browserWindow](browser-window-ko.md) gets focused.
### Event: 'select-certificate'
Emitted when client certificate is requested.
* `event` Event
* `webContents` [WebContents](browser-window-ko.md#class-webcontents)
* `url` String
* `certificateList` [Objects]
* `data` PEM encoded data
* `issuerName` Issuer's Common Name
* `callback` Function
```
app.on('select-certificate', function(event, host, url, list, callback) {
event.preventDefault();
callback(list[0]);
})
```
`url` corresponds to the navigation entry requesting the client certificate,
`callback` needs to be called with an entry filtered from the list.
`event.preventDefault()` prevents from using the first certificate from
the store.
### Event: 'gpu-process-crashed'
Emitted when the gpu process is crashed.
## app.quit()
Try to close all windows. The `before-quit` event will first be emitted. If all
windows are successfully closed, the `will-quit` event will be emitted and by
default the application would be terminated.
This method guarantees all `beforeunload` and `unload` handlers are correctly
executed. It is possible that a window cancels the quitting by returning
`false` in `beforeunload` handler.
## app.getPath(name)
* `name` String
Retrieves a path to a special directory or file associated with `name`. On
failure an `Error` would throw.
You can request following paths by the names:
* `home`: User's home directory
* `appData`: Per-user application data directory, by default it is pointed to:
* `%APPDATA%` on Windows
* `$XDG_CONFIG_HOME` or `~/.config` on Linux
* `~/Library/Application Support` on OS X
* `userData`: The directory for storing your app's configuration files, by
default it is the `appData` directory appended with your app's name
* `cache`: Per-user application cache directory, by default it is pointed to:
* `%APPDATA%` on Window, which doesn't has a universal place for cache
* `$XDG_CACHE_HOME` or `~/.cache` on Linux
* `~/Library/Caches` on OS X
* `userCache`: The directory for placing your app's caches, by default it is the
`cache` directory appended with your app's name
* `temp`: Temporary directory
* `userDesktop`: The current user's Desktop directory
* `exe`: The current executable file
* `module`: The `libchromiumcontent` library
## app.setPath(name, path)
* `name` String
* `path` String
Overrides the `path` to a special directory or file associated with `name`. if
the path specifies a directory that does not exist, the directory will be
created by this method. On failure an `Error` would throw.
You can only override paths of `name`s defined in `app.getPath`.
By default web pages' cookies and caches will be stored under `userData`
directory, if you want to change this location, you have to override the
`userData` path before the `ready` event of `app` module gets emitted.
## app.getVersion()
Returns the version of loaded application, if no version is found in
application's `package.json`, the version of current bundle or executable would
be returned.
## app.getName()
Returns current application's name, the name in `package.json` would be
used.
Usually the `name` field of `package.json` is a short lowercased name, according
to the spec of npm modules. So usually you should also specify a `productName`
field, which is your application's full capitalized name, and it will be
preferred over `name` by Electron.
## app.resolveProxy(url, callback)
* `url` URL
* `callback` Function
Resolves the proxy information for `url`, the `callback` would be called with
`callback(proxy)` when the request is done.
## app.addRecentDocument(path)
* `path` String
Adds `path` to recent documents list.
This list is managed by the system, on Windows you can visit the list from task
bar, and on Mac you can visit it from dock menu.
## app.clearRecentDocuments()
Clears the recent documents list.
## app.setUserTasks(tasks)
* `tasks` Array - Array of `Task` objects
Adds `tasks` to the [Tasks][tasks] category of JumpList on Windows.
The `tasks` is an array of `Task` objects in following format:
* `Task` Object
* `program` String - Path of the program to execute, usually you should
specify `process.execPath` which opens current program
* `arguments` String - The arguments of command line when `program` is
executed
* `title` String - The string to be displayed in a JumpList
* `description` String - Description of this task
* `iconPath` String - The absolute path to an icon to be displayed in a
JumpList, it can be arbitrary resource file that contains an icon, usually
you can specify `process.execPath` to show the icon of the program
* `iconIndex` Integer - The icon index in the icon file. If an icon file
consists of two or more icons, set this value to identify the icon. If an
icon file consists of one icon, this value is 0
**Note:** This API is only available on Windows.
## app.commandLine.appendSwitch(switch, [value])
Append a switch [with optional value] to Chromium's command line.
**Note:** This will not affect `process.argv`, and is mainly used by developers
to control some low-level Chromium behaviors.
## app.commandLine.appendArgument(value)
Append an argument to Chromium's command line. The argument will quoted properly.
**Note:** This will not affect `process.argv`.
## app.dock.bounce([type])
* `type` String - Can be `critical` or `informational`, the default is
`informational`
When `critical` is passed, the dock icon will bounce until either the
application becomes active or the request is canceled.
When `informational` is passed, the dock icon will bounce for one second. The
request, though, remains active until either the application becomes active or
the request is canceled.
An ID representing the request would be returned.
**Note:** This API is only available on Mac.
## app.dock.cancelBounce(id)
* `id` Integer
Cancel the bounce of `id`.
**Note:** This API is only available on Mac.
## app.dock.setBadge(text)
* `text` String
Sets the string to be displayed in the dock’s badging area.
**Note:** This API is only available on Mac.
## app.dock.getBadge()
Returns the badge string of the dock.
**Note:** This API is only available on Mac.
## app.dock.hide()
Hides the dock icon.
**Note:** This API is only available on Mac.
## app.dock.show()
Shows the dock icon.
**Note:** This API is only available on Mac.
## app.dock.setMenu(menu)
* `menu` Menu
Sets the application [dock menu][dock-menu].
**Note:** This API is only available on Mac.
[dock-menu]:https://developer.apple.com/library/mac/documentation/Carbon/Conceptual/customizing_docktile/concepts/dockconcepts.html#//apple_ref/doc/uid/TP30000986-CH2-TPXREF103
[tasks]:http://msdn.microsoft.com/en-us/library/windows/desktop/dd378460(v=vs.85).aspx#tasks

143
docs/api/auto-updater-ko.md Normal file
View file

@ -0,0 +1,143 @@
# auto-updater
**This module has only been implemented for OS X.**
Check out [atom/grunt-electron-installer](https://github.com/atom/grunt-electron-installer)
for building a Windows installer for your app.
The `auto-updater` module is a simple wrap around the
[Squirrel.Mac](https://github.com/Squirrel/Squirrel.Mac) framework.
Squirrel.Mac requires that your `.app` folder is signed using the
[codesign](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/codesign.1.html)
utility for updates to be installed.
## Squirrel
Squirrel is an OS X framework focused on making application updates **as safe
and transparent as updates to a website**.
Instead of publishing a feed of versions from which your app must select,
Squirrel updates to the version your server tells it to. This allows you to
intelligently update your clients based on the request you give to Squirrel.
Your request can include authentication details, custom headers or a request
body so that your server has the context it needs in order to supply the most
suitable update.
The update JSON Squirrel requests should be dynamically generated based on
criteria in the request, and whether an update is required. Squirrel relies
on server side support for determining whether an update is required, see
[Server Support](#server-support).
Squirrel's installer is also designed to be fault tolerant, and ensure that any
updates installed are valid.
## Update Requests
Squirrel is indifferent to the request the client application provides for
update checking. `Accept: application/json` is added to the request headers
because Squirrel is responsible for parsing the response.
For the requirements imposed on the responses and the body format of an update
response see [Server Support](#server-support).
Your update request must *at least* include a version identifier so that the
server can determine whether an update for this specific version is required. It
may also include other identifying criteria such as operating system version or
username, to allow the server to deliver as fine grained an update as you
would like.
How you include the version identifier or other criteria is specific to the
server that you are requesting updates from. A common approach is to use query
parameters, like this:
```javascript
// On the main process
var app = require('app');
var autoUpdater = require('auto-updater');
autoUpdater.setFeedUrl('http://mycompany.com/myapp/latest?version=' + app.getVersion());
```
## Server Support
Your server should determine whether an update is required based on the
[Update Request](#update-requests) your client issues.
If an update is required your server should respond with a status code of
[200 OK](http://tools.ietf.org/html/rfc2616#section-10.2.1) and include the
[update JSON](#update-json-format) in the body. Squirrel **will** download and
install this update, even if the version of the update is the same as the
currently running version. To save redundantly downloading the same version
multiple times your server must not inform the client to update.
If no update is required your server must respond with a status code of
[204 No Content](http://tools.ietf.org/html/rfc2616#section-10.2.5). Squirrel
will check for an update again at the interval you specify.
## Update JSON Format
When an update is available, Squirrel expects the following schema in response
to the update request provided:
```json
{
"url": "http://mycompany.com/myapp/releases/myrelease",
"name": "My Release Name",
"notes": "Theses are some release notes innit",
"pub_date": "2013-09-18T12:29:53+01:00",
}
```
The only required key is "url", the others are optional.
Squirrel will request "url" with `Accept: application/zip` and only supports
installing ZIP updates. If future update formats are supported their MIME type
will be added to the `Accept` header so that your server can return the
appropriate format.
`pub_date` if present must be formatted according to ISO 8601.
## Event: error
* `event` Event
* `message` String
Emitted when there is an error updating.
## Event: checking-for-update
Emitted when checking for update has started.
## Event: update-available
Emitted when there is an available update, the update would be downloaded
automatically.
## Event: update-not-available
Emitted when there is no available update.
## Event: update-downloaded
* `event` Event
* `releaseNotes` String
* `releaseName` String
* `releaseDate` Date
* `updateUrl` String
* `quitAndUpdate` Function
Emitted when update has been downloaded, calling `quitAndUpdate()` would restart
the application and install the update.
## autoUpdater.setFeedUrl(url)
* `url` String
Set the `url` and initialize the auto updater. The `url` could not be changed
once it is set.
## autoUpdater.checkForUpdates()
Ask the server whether there is an update, you have to call `setFeedUrl` before
using this API.

1143
docs/api/browser-window-ko.md Normal file
View file

File diff suppressed because it is too large Load diff

109
docs/api/chrome-command-line-switches-ko.md Normal file
View file

@ -0,0 +1,109 @@
# 크롬 Command-Line 스위치 지원
The following command lines switches in Chrome browser are also supported in
Electron, you can use [app.commandLine.appendSwitch][append-switch] to append
them in your app's main script before the [ready][ready] event of [app][app]
module is emitted:
```javascript
var app = require('app');
app.commandLine.appendSwitch('remote-debugging-port', '8315');
app.commandLine.appendSwitch('host-rules', 'MAP * 127.0.0.1');
app.on('ready', function() {
// Your code here
});
```
## --client-certificate=`path`
Sets `path` of client certificate file.
## --ignore-connections-limit=`domains`
Ignore the connections limit for `domains` list seperated by `,`.
## --disable-http-cache
Disables the disk cache for HTTP requests.
## --remote-debugging-port=`port`
Enables remote debug over HTTP on the specified `port`.
## --proxy-server=`address:port`
Uses a specified proxy server, overrides system settings. This switch only
affects HTTP and HTTPS requests.
## --no-proxy-server
Don't use a proxy server, always make direct connections. Overrides any other
proxy server flags that are passed.
## --host-rules=`rules`
Comma-separated list of `rules` that control how hostnames are mapped.
For example:
* `MAP * 127.0.0.1` Forces all hostnames to be mapped to 127.0.0.1
* `MAP *.google.com proxy` Forces all google.com subdomains to be resolved to
"proxy".
* `MAP test.com [::1]:77` Forces "test.com" to resolve to IPv6 loopback. Will
also force the port of the resulting socket address to be 77.
* `MAP * baz, EXCLUDE www.google.com` Remaps everything to "baz", except for
"www.google.com".
These mappings apply to the endpoint host in a net request (the TCP connect
and host resolver in a direct connection, and the `CONNECT` in an http proxy
connection, and the endpoint host in a `SOCKS` proxy connection).
## --host-resolver-rules=`rules`
Like `--host-rules` but these `rules` only apply to the host resolver.
[app]: app-ko.md
[append-switch]: app-ko.md#appcommandlineappendswitchswitch-value
[ready]: app-ko.md#event-ready
## --ignore-certificate-errors
Ignores certificate related errors.
## --ppapi-flash-path=`path`
Sets `path` of pepper flash plugin.
## --ppapi-flash-version=`version`
Sets `version` of pepper flash plugin.
## --log-net-log=`path`
Enables saving net log events and writes them to `path`.
## --v=`log_level`
Gives the default maximal active V-logging level; 0 is the default. Normally
positive values are used for V-logging levels.
Passing `--v=-1` will disable logging.
## --vmodule=`pattern`
Gives the per-module maximal V-logging levels to override the value given by
`--v`. E.g. `my_module=2,foo*=3` would change the logging level for all code in
source files `my_module.*` and `foo*.*`.
Any pattern containing a forward or backward slash will be tested against the
whole pathname and not just the module. E.g. `*/foo/bar/*=2` would change the
logging level for all code in source files under a `foo/bar` directory.
To disable all chromium related logs and only enable your application logs you
can do:
```javascript
app.commandLine.appendSwitch('v', -1);
app.commandLine.appendSwitch('vmodule', 'console=0');
```

88
docs/api/clipboard-ko.md Normal file
View file

@ -0,0 +1,88 @@
# clipboard
`clipboard`는 복사/붙여넣기 작업을 수행하는 방법을 제공합니다. 다음 예제는 클립보드에 문자열을 씁니다:
```javascript
var clipboard = require('clipboard');
clipboard.writeText('Example String');
```
X Window 시스템에선 selection 클립보드도 존재합니다. 이를 사용하려면 인자 뒤에 `selection` 문자열을 같이 지정해주어야 합니다:
```javascript
var clipboard = require('clipboard');
clipboard.writeText('Example String', 'selection');
console.log(clipboard.readText('selection'));
```
## clipboard.readText([type])
* `type` String
클립보드 컨텐츠를 `plain text`로 반환합니다.
## clipboard.writeText(text[, type])
* `text` String
* `type` String
클립보드에 `plain text`로 문자열을 씁니다.
## clipboard.readHtml([type])
* `type` String
클립보드 컨텐츠를 `markup`으로 반환합니다.
## clipboard.writeHtml(markup[, type])
* `markup` String
* `type` String
클립보드에 `markup`으로 씁니다.
## clipboard.readImage([type])
* `type` String
클립보드로부터 [NativeImage](native-image-ko.md)로 이미지를 읽어들입니다.
## clipboard.writeImage(image[, type])
* `image` [NativeImage](native-image-ko.md)
* `type` String
클립보드에 `image`를 씁니다.
## clipboard.clear([type])
* `type` String
클립보드에 저장된 모든 컨텐츠를 삭제합니다.
## clipboard.availableFormats([type])
클립보드의 `type`에 해당하는 지원하는 `format`을 문자열로 반환합니다.
## clipboard.has(data[, type])
* `data` String
* `type` String
클립보드가 지정한 `data`의 형식을 지원하는지 확인합니다.
```javascript
var clipboard = require('clipboard');
console.log(clipboard.has('<p>selection</p>'));
```
**알림:** 이 API는 실험적인 기능이며 차후 최신버전에서 제외될 수 있습니다.
## clipboard.read(data[, type])
* `data` String
* `type` String
클립보드로부터 `data`를 읽어들입니다.
**알림:** 이 API는 실험적인 기능이며 차후 최신버전에서 제외될 수 있습니다.

137
docs/api/content-tracing-ko.md Normal file
View file

@ -0,0 +1,137 @@
# content-tracing
The `content-trace` module is used to collect tracing data generated by the
underlying Chromium content module. 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.
```javascript
var tracing = require('content-tracing');
tracing.startRecording('*', tracing.DEFAULT_OPTIONS, function() {
console.log('Tracing started');
setTimeout(function() {
tracing.stopRecording('', function(path) {
console.log('Tracing data recorded to ' + path);
});
}, 5000);
});
```
## tracing.getCategories(callback)
* `callback` Function
Get a set of category groups. The category groups can change as new code paths
are reached.
Once all child processes have acked to the `getCategories` request, `callback`
is invoked with an array of category groups.
## tracing.startRecording(categoryFilter, options, callback)
* `categoryFilter` String
* `options` Integer
* `callback` Function
Start recording on all processes.
Recording begins immediately locally, and asynchronously on child processes
as soon as they receive the EnableRecording request. Once all child processes
have acked to the `startRecording` request, `callback` will be called back.
`categoryFilter` is a filter to control what category groups should be
traced. A filter can have an optional `-` prefix to exclude category groups
that contain a matching category. Having both included and excluded
category patterns in the same list is not supported.
Examples:
* `test_MyTest*`,
* `test_MyTest*,test_OtherStuff`,
* `"-excluded_category1,-excluded_category2`
`options` controls what kind of tracing is enabled, it could be a OR-ed
combination of `tracing.DEFAULT_OPTIONS`, `tracing.ENABLE_SYSTRACE`,
`tracing.ENABLE_SAMPLING` and `tracing.RECORD_CONTINUOUSLY`.
## tracing.stopRecording(resultFilePath, callback)
* `resultFilePath` String
* `callback` Function
Stop recording on all processes.
Child processes typically are caching trace data and only rarely flush and send
trace data back to the main process. That is because it may be an expensive
operation to send the trace data over IPC, and we would like to avoid much
runtime overhead of tracing. So, to end tracing, we must asynchronously ask all
child processes to flush any pending trace data.
Once all child processes have acked to the `stopRecording` request, `callback`
will be called back with a file that contains the traced data.
Trace data will be written into `resultFilePath` if it is not empty, or into a
temporary file. The actual file path will be passed to `callback` if it's not
null.
## tracing.startMonitoring(categoryFilter, options, callback)
* `categoryFilter` String
* `options` Integer
* `callback` Function
Start monitoring on all processes.
Monitoring begins immediately locally, and asynchronously on child processes as
soon as they receive the `startMonitoring` request.
Once all child processes have acked to the `startMonitoring` request,
`callback` will be called back.
## tracing.stopMonitoring(callback);
* `callback` Function
Stop monitoring on all processes.
Once all child processes have acked to the `stopMonitoring` request, `callback`
is called back.
## tracing.captureMonitoringSnapshot(resultFilePath, callback)
* `resultFilePath` String
* `callback` Function
Get the current monitoring traced data.
Child processes typically are caching trace data and only rarely flush and send
trace data back to the main process. That is because it may be an expensive
operation to send the trace data over IPC, and we would like to avoid unneeded
runtime overhead of tracing. So, to end tracing, we must asynchronously ask all
child processes to flush any pending trace data.
Once all child processes have acked to the `captureMonitoringSnapshot` request,
the `callback` will be invoked with a file that contains the traced data.
## tracing.getTraceBufferUsage(callback)
* `callback` Function
Get the maximum across processes of trace buffer percent full state. When the
TraceBufferUsage value is determined, the `callback` is called.
## tracing.setWatchEvent(categoryName, eventName, callback)
* `categoryName` String
* `eventName` String
* `callback` Function
`callback` will will be called every time the given event occurs on any
process.
## tracing.cancelWatchEvent()
Cancel the watch event. If tracing is enabled, this may race with the watch
event callback.

61
docs/api/crash-reporter-ko.md Normal file
View file

@ -0,0 +1,61 @@
# crash-reporter
An example of automatically submitting crash reporters to remote server:
```javascript
crashReporter = require('crash-reporter');
crashReporter.start({
productName: 'YourName',
companyName: 'YourCompany',
submitUrl: 'https://your-domain.com/url-to-submit',
autoSubmit: true
});
```
## crashReporter.start(options)
* `options` Object
* `productName` String, default: Electron
* `companyName` String, default: GitHub, Inc
* `submitUrl` String, default: http://54.249.141.255:1127/post
* URL that crash reports would be sent to as POST
* `autoSubmit` Boolean, default: true
* Send the crash report without user interaction
* `ignoreSystemCrashHandler` Boolean, default: false
* `extra` Object
* An object you can define which content will be send along with the report.
* Only string properties are send correctly.
* Nested objects are not supported.
Developers are required to call the API before using other crashReporter APIs.
**Note:** On OS X, electron uses a new `crashpad` client, which is different
with the `breakpad` on Windows and Linux. To enable crash collection feature,
you are required to call `crashReporter.start` API to initiliaze `crashpad` in
main process, even you only collect crash report in renderer process.
## crashReporter.getLastCrashReport()
Returns the date and ID of last crash report, when there was no crash report
sent or the crash reporter is not started, `null` will be returned.
## crashReporter.getUploadedReports()
Returns all uploaded crash reports, each report contains date and uploaded ID.
# crash-reporter payload
The crash reporter will send the following data to the `submitUrl` as `POST`:
* `rept` String - e.g. 'electron-crash-service'
* `ver` String - The version of Electron
* `platform` String - e.g. 'win32'
* `process_type` String - e.g. 'renderer'
* `ptime` Number
* `_version` String - The version in `package.json`
* `_productName` String - The product name in the crashReporter `options` object
* `prod` String - Name of the underlying product. In this case Electron
* `_companyName` String - The company name in the crashReporter `options` object
* `upload_file_minidump` File - The crashreport as file
* All level one properties of the `extra` object in the crashReporter `options` object

92
docs/api/dialog-ko.md Normal file
View file

@ -0,0 +1,92 @@
# dialog
The `dialog` module provides APIs to show native system dialogs, so web
applications can deliver the same user experience as native applications.
An example of showing a dialog to select multiple files and directories:
```javascript
var win = ...; // window in which to show the dialog
var dialog = require('dialog');
console.log(dialog.showOpenDialog({ properties: [ 'openFile', 'openDirectory', 'multiSelections' ]}));
```
**Note for OS X**: If you want to present dialogs as sheets, the only thing you have to do is provide a `BrowserWindow` reference in the `browserWindow` parameter.
## dialog.showOpenDialog([browserWindow], [options], [callback])
* `browserWindow` BrowserWindow
* `options` Object
* `title` String
* `defaultPath` String
* `filters` Array
* `properties` Array - Contains which features the dialog should use, can
contain `openFile`, `openDirectory`, `multiSelections` and
`createDirectory`
* `callback` Function
On success, returns an array of file paths chosen by the user, otherwise
returns `undefined`.
The `filters` specifies an array of file types that can be displayed or
selected, an example is:
```javascript
{
filters: [
{ name: 'Images', extensions: ['jpg', 'png', 'gif'] },
{ name: 'Movies', extensions: ['mkv', 'avi', 'mp4'] },
{ name: 'Custom File Type', extensions: ['as'] }
]
}
```
If a `callback` is passed, the API call would be asynchronous and the result
would be passed via `callback(filenames)`
**Note:** On Windows and Linux, an open dialog can not be both a file selector
and a directory selector, so if you set `properties` to
`['openFile', 'openDirectory']` on these platforms, a directory selector will be shown.
## dialog.showSaveDialog([browserWindow], [options], [callback])
* `browserWindow` BrowserWindow
* `options` Object
* `title` String
* `defaultPath` String
* `filters` Array
* `callback` Function
On success, returns the path of the file chosen by the user, otherwise returns
`undefined`.
The `filters` specifies an array of file types that can be displayed, see
`dialog.showOpenDialog` for an example.
If a `callback` is passed, the API call will be asynchronous and the result
will be passed via `callback(filename)`
## dialog.showMessageBox([browserWindow], options, [callback])
* `browserWindow` BrowserWindow
* `options` Object
* `type` String - Can be `"none"`, `"info"` or `"warning"`
* `buttons` Array - Array of texts for buttons
* `title` String - Title of the message box, some platforms will not show it
* `message` String - Content of the message box
* `detail` String - Extra information of the message
* `icon` [NativeImage](native-image-ko.md)
* `callback` Function
Shows a message box, it will block until the message box is closed. It returns
the index of the clicked button.
If a `callback` is passed, the API call will be asynchronous and the result
will be passed via `callback(response)`
## dialog.showErrorBox(title, content)
Runs a modal dialog that shows an error message.
This API can be called safely before the `ready` event of `app` module emits, it
is usually used to report errors in early stage of startup.

28
docs/api/file-object-ko.md Normal file
View file

@ -0,0 +1,28 @@
# `File` 객체
DOM의 File 인터페이스는 네이티브 파일을 추상화 합니다. 유저가 직접적으로 HTML5 File API를 사용하여 작업할 때 파일의 경로를
알 수 있도록 Electron은 파일시스템의 실제 파일 경로를 담은 `path` 속성을 File 인터페이스에 추가하였습니다.
다음 예제는 drag n drop한 파일의 실제 경로를 가져옵니다:
```html
<div id="holder">
Drag your file here
</div>
<script>
var holder = document.getElementById('holder');
holder.ondragover = function () {
return false;
};
holder.ondragleave = holder.ondragend = function () {
return false;
};
holder.ondrop = function (e) {
e.preventDefault();
var file = e.dataTransfer.files[0];
console.log('File you dragged here is', file.path);
return false;
};
</script>
```

89
docs/api/frameless-window-ko.md Normal file
View file

@ -0,0 +1,89 @@
# Frameless window
A frameless window is a window that has no chrome.
## Create a frameless window
To create a frameless window, you only need to specify `frame` to `false` in
[BrowserWindow](browser-window-ko.md)'s `options`:
```javascript
var BrowserWindow = require('browser-window');
var win = new BrowserWindow({ width: 800, height: 600, frame: false });
```
## Transparent window
By setting the `transparent` option to `true`, you can also make the frameless
window transparent:
```javascript
var win = new BrowserWindow({ transparent: true, frame: false });
```
### Limitations
* You can not click through the transparent area, we are going to introduce an
API to set window shape to solve this, but currently blocked at an
[upstream bug](https://code.google.com/p/chromium/issues/detail?id=387234).
* Transparent window is not resizable, setting `resizable` to `true` may make
transparent window stop working on some platforms.
* The `blur` filter only applies to the web page, so there is no way to apply
blur effect to the content below the window.
* On Windows transparent window will not work when DWM is disabled.
* On Linux users have to put `--enable-transparent-visuals --disable-gpu` in
command line to disable GPU and allow ARGB to make transparent window, this is
caused by an upstream bug that [alpha channel doesn't work on some NVidia
drivers](https://code.google.com/p/chromium/issues/detail?id=369209) on Linux.
* On Mac the native window shadow will not show for transparent window.
## Draggable region
By default, the frameless window is non-draggable. Apps need to specify
`-webkit-app-region: drag` in CSS to tell Electron which regions are draggable
(like the OS's standard titlebar), and apps can also use
`-webkit-app-region: no-drag` to exclude the non-draggable area from the
draggable region. Note that only rectangular shape is currently supported.
To make the whole window draggable, you can add `-webkit-app-region: drag` as
`body`'s style:
```html
<body style="-webkit-app-region: drag">
</body>
```
And note that if you have made the whole window draggable, you must also mark
buttons as non-draggable, otherwise it would be impossible for users to click on
them:
```css
button {
-webkit-app-region: no-drag;
}
```
If you're only using a custom titlebar, you also need to make buttons in
titlebar non-draggable.
## Text selection
One thing on frameless window is that the dragging behaviour may conflict with
selecting text, for example, when you drag the titlebar, you may accidentally
select the text on titlebar. To prevent this, you need to disable text
selection on dragging area like this:
```css
.titlebar {
-webkit-user-select: none;
-webkit-app-region: drag;
}
```
## Context menu
On some platforms, the draggable area would be treated as non-client frame, so
when you right click on it a system menu would be popuped. To make context menu
behave correctly on all platforms, you should never custom context menu on
draggable areas.

47
docs/api/global-shortcut-ko.md Normal file
View file

@ -0,0 +1,47 @@
# global-shortcut
`global-shortcut` 모듈은 사용자가 다양한 단축키 작업을 정의 할 수 있도록 운영체제의 전역 키보드 단축키를 설정 등록/해제 하는 방법을 제공합니다.
참고로 설정된 단축키는 어플리케이션이 백그라운드로 작동(창이 포커스 되지 않음) 할 때도 여전히 계속 작동합니다.
```javascript
var globalShortcut = require('global-shortcut');
// 'ctrl+x' 단축키를 리스너에 등록합니다.
var ret = globalShortcut.register('ctrl+x', function() { console.log('ctrl+x is pressed'); })
if (!ret) {
console.log('registration failed');
}
// 단축키가 등록되었는지 확인합니다.
console.log(globalShortcut.isRegistered('ctrl+x'));
// 단축키의 등록을 해제합니다.
globalShortcut.unregister('ctrl+x');
// 모든 단축키의 등록을 해제합니다.
globalShortcut.unregisterAll();
```
## globalShortcut.register(accelerator, callback)
* `accelerator` [Accelerator](accelerator-ko.md)
* `callback` Function
`accelerator`로 표현된 전역 단축키를 등록합니다. 유저로부터 등록된 단축키가 눌렸을 경우 `callback` 함수가 호출됩니다.
## globalShortcut.isRegistered(accelerator)
* `accelerator` [Accelerator](accelerator-ko.md)
지정된 `accelerator` 단축키가 등록되었는지 여부를 확인합니다. 반환값은 boolean(true, false) 입니다.
## globalShortcut.unregister(accelerator)
* `accelerator` [Accelerator](accelerator-ko.md)
`키코드`에 해당하는 전역 단축키를 등록 해제합니다.
## globalShortcut.unregisterAll()
모든 전역 단축키 등록을 해제합니다.

46
docs/api/ipc-main-process-ko.md Normal file
View file

@ -0,0 +1,46 @@
# ipc (main process)
랜더러 프로세스(웹 페이지)로 부터 동기 또는 비동기로 메시지를 받아 처리합니다.
랜더러로부터 발신된 메시지들은 모두 이 모듈에서 `channel` 이라는 특정 이벤트 이름을 통해 수신할 수 있습니다.
동기 메시지는 `event.returnValue`를 이용하여 반환값(답장)을 설정할 수 있습니다. 비동기 메시지라면 `event.sender.send(...)`를 사용하면 됩니다.
또한 메인 프로세스에서 랜더러 프로세스로 메시지를 보내는 것도 가능합니다.
자세한 내용은 [WebContents.send](browser-window-ko.md#webcontentssendchannel-args)를 참고 하세요.
보내진 메시지들을 처리하는 예제입니다:
```javascript
// 메인 프로세스에서 처리.
var ipc = require('ipc');
ipc.on('asynchronous-message', function(event, arg) {
console.log(arg); // prints "ping"
event.sender.send('asynchronous-reply', 'pong');
});
ipc.on('synchronous-message', function(event, arg) {
console.log(arg); // prints "ping"
event.returnValue = 'pong';
});
```
```javascript
// 랜더러 프로세스에서의 처리 (web page).
var ipc = require('ipc');
console.log(ipc.sendSync('synchronous-message', 'ping')); // prints "pong"
ipc.on('asynchronous-reply', function(arg) {
console.log(arg); // prints "pong"
});
ipc.send('asynchronous-message', 'ping');
```
## Class: Event
### Event.returnValue
동기 메시지를 설정합니다.
### Event.sender
메시지를 보내온 sender `WebContents` 객체입니다.

25
docs/api/ipc-renderer-ko.md Normal file
View file

@ -0,0 +1,25 @@
# ipc (renderer)
`ipc` 모듈은 메인 프로세스로 메시지를 동기 또는 비동기로 보내고 받을 수 있는 몇 가지 방법을 제공합니다.
만약 랜더러 프로세스에서 메인 프로세스의 모듈을 직접적으로 사용하고 싶다면 [remote](remote-ko.md) 모듈을 사용하는 것을 고려해보는 것이 좋습니다.
[ipc (main process)](ipc-main-process-ko.md)에서 예제를 볼 수 있습니다.
## ipc.send(channel[, args...])
지정한 `channel`을 통해 `args..`를 비동기로 메시지를 보냅니다. 메인 프로세스는 `ipc` 모듈의 `channel` 이벤트를 통해 메시지를 받을 수 있습니다.
## ipc.sendSync(channel[, args...])
지정한 `channel`을 통해 `args..`를 동기로 메시지를 보냅니다. 그리고 메인 프로세스에서 보낸 결과를 반환합니다.
메인 프로세스는 `ipc` 모듈의 `channel` 이벤트를 통해 메시지를 받을 수 있습니다. 그리고 `event.returnValue`를 통해 반환값을 설정할 수 있습니다.
역자 주: `channel`은 이벤트 이름입니다.
**알림:** 보통 개발자들은 해당 API를 사용하려 하지 않습니다. 동기 ipc 작업은 랜더러 프로세스의 모든 작업을 중단시킵니다.
## ipc.sendToHost(channel[, args...])
`ipc.send`와 비슷하지만 메시지를 메인 프로세스 대신 호스트 페이지로 보냅니다.
이 메소드는 보통 `<webview>`와 호스트 페이지 간의 통신에 사용됩니다.

18
docs/api/menu-item-ko.md
View file

@ -1,20 +1,20 @@
# menu-item
# menu-item
## Class: MenuItem
### new MenuItem(options)
* `options` Object
* `click` Function - 메뉴 아이템이 클릭될 때 호출되는 콜백함수
* `selector` String - First Responder가 클릭될 때 호출 되는 선택자 (OS X 전용)
* `type` String - `MenuItem`의 타입 `normal`, `separator`, `submenu`, `checkbox` 또는 `radio` 사용가능
* `click` Function - 메뉴 아이템이 클릭될 때 호출되는 콜백함수
* `selector` String - First Responder가 클릭될 때 호출 되는 선택자 (OS X 전용)
* `type` String - `MenuItem`의 타입 `normal`, `separator`, `submenu`, `checkbox` 또는 `radio` 사용가능
* `label` String
* `sublabel` String
* `accelerator` [Accelerator](accelerator.md)
* `icon` [NativeImage](native-image.md)
* `accelerator` [Accelerator](accelerator-ko.md)
* `icon` [NativeImage](native-image-ko.md)
* `enabled` Boolean
* `visible` Boolean
* `checked` Boolean
* `submenu` Menu - 보조메뉴를 설정합니다. `type`이 `submenu`일 경우 반드시 설정해야합니다. 일반 메뉴 아이템일 경우 생략할 수 있습니다.
* `id` String - 현재 메뉴 아이템에 대해 유일키를 지정합니다. 이 키는 이후 `position` 옵션에서 사용할 수 있습니다.
* `position` String - 미리 지정한 `id`를 이용하여 메뉴 아이템의 위치를 세밀하게 조정합니다.
* `submenu` Menu - 보조메뉴를 설정합니다. `type`이 `submenu`일 경우 반드시 설정해야합니다. 일반 메뉴 아이템일 경우 생략할 수 있습니다.
* `id` String - 현재 메뉴 아이템에 대해 유일키를 지정합니다. 이 키는 이후 `position` 옵션에서 사용할 수 있습니다.
* `position` String - 미리 지정한 `id`를 이용하여 메뉴 아이템의 위치를 세밀하게 조정합니다.

330
docs/api/menu-ko.md Normal file
View file

@ -0,0 +1,330 @@
# menu
The `Menu` class is used to create native menus that can be used as
application menus and context menus. Each menu consists of multiple menu
items, and each menu item can have a submenu.
Below is an example of creating a menu dynamically in a web page by using
the [remote](remote-ko.md) module, and showing it when the user right clicks
the page:
```html
<!-- index.html -->
<script>
var remote = require('remote');
var Menu = remote.require('menu');
var MenuItem = remote.require('menu-item');
var menu = new Menu();
menu.append(new MenuItem({ label: 'MenuItem1', click: function() { console.log('item 1 clicked'); } }));
menu.append(new MenuItem({ type: 'separator' }));
menu.append(new MenuItem({ label: 'MenuItem2', type: 'checkbox', checked: true }));
window.addEventListener('contextmenu', function (e) {
e.preventDefault();
menu.popup(remote.getCurrentWindow());
}, false);
</script>
```
Another example of creating the application menu with the simple template API:
```html
<!-- index.html -->
<script>
var remote = require('remote');
var Menu = remote.require('menu');
var template = [
{
label: 'Electron',
submenu: [
{
label: 'About Electron',
selector: 'orderFrontStandardAboutPanel:'
},
{
type: 'separator'
},
{
label: 'Services',
submenu: []
},
{
type: 'separator'
},
{
label: 'Hide Electron',
accelerator: 'Command+H',
selector: 'hide:'
},
{
label: 'Hide Others',
accelerator: 'Command+Shift+H',
selector: 'hideOtherApplications:'
},
{
label: 'Show All',
selector: 'unhideAllApplications:'
},
{
type: 'separator'
},
{
label: 'Quit',
accelerator: 'Command+Q',
selector: 'terminate:'
},
]
},
{
label: 'Edit',
submenu: [
{
label: 'Undo',
accelerator: 'Command+Z',
selector: 'undo:'
},
{
label: 'Redo',
accelerator: 'Shift+Command+Z',
selector: 'redo:'
},
{
type: 'separator'
},
{
label: 'Cut',
accelerator: 'Command+X',
selector: 'cut:'
},
{
label: 'Copy',
accelerator: 'Command+C',
selector: 'copy:'
},
{
label: 'Paste',
accelerator: 'Command+V',
selector: 'paste:'
},
{
label: 'Select All',
accelerator: 'Command+A',
selector: 'selectAll:'
}
]
},
{
label: 'View',
submenu: [
{
label: 'Reload',
accelerator: 'Command+R',
click: function() { remote.getCurrentWindow().reload(); }
},
{
label: 'Toggle DevTools',
accelerator: 'Alt+Command+I',
click: function() { remote.getCurrentWindow().toggleDevTools(); }
},
]
},
{
label: 'Window',
submenu: [
{
label: 'Minimize',
accelerator: 'Command+M',
selector: 'performMiniaturize:'
},
{
label: 'Close',
accelerator: 'Command+W',
selector: 'performClose:'
},
{
type: 'separator'
},
{
label: 'Bring All to Front',
selector: 'arrangeInFront:'
}
]
},
{
label: 'Help',
submenu: []
}
];
menu = Menu.buildFromTemplate(template);
Menu.setApplicationMenu(menu);
</script>
```
## Class: Menu
### new Menu()
Creates a new menu.
### Class Method: Menu.setApplicationMenu(menu)
* `menu` Menu
Sets `menu` as the application menu on OS X. On Windows and Linux, the `menu`
will be set as each window's top menu.
### Class Method: Menu.sendActionToFirstResponder(action)
* `action` String
Sends the `action` to the first responder of application, this is used for
emulating default Cocoa menu behaviors, usually you would just use the
`selector` property of `MenuItem`.
**Note:** This method is OS X only.
### Class Method: Menu.buildFromTemplate(template)
* `template` Array
Generally, the `template` is just an array of `options` for constructing
[MenuItem](menu-item-ko.md), the usage can be referenced above.
You can also attach other fields to element of the `template`, and they will
become properties of the constructed menu items.
### Menu.popup(browserWindow, [x, y])
* `browserWindow` BrowserWindow
* `x` Number
* `y` Number
Popups this menu as a context menu in the `browserWindow`. You can optionally
provide a `(x,y)` coordinate to place the menu at, otherwise it will be placed
at the current mouse cursor position.
### Menu.append(menuItem)
* `menuItem` MenuItem
Appends the `menuItem` to the menu.
### Menu.insert(pos, menuItem)
* `pos` Integer
* `menuItem` MenuItem
Inserts the `menuItem` to the `pos` position of the menu.
### Menu.items
Get the array containing the menu's items.
## Notes on OS X application menu
OS X has a completely different style of application menu from Windows and
Linux, and here are some notes on making your app's menu more native-like.
### Standard menus
On OS X there are many system defined standard menus, like the `Services` and
`Windows` menus. To make your menu a standard menu, you can just set your menu's
label to one of followings, and Electron will recognize them and make them
become standard menus:
* `Window`
* `Help`
* `Services`
### Standard menu item actions
OS X has provided standard actions for some menu items (which are called
`selector`s), like `About xxx`, `Hide xxx`, and `Hide Others`. To set the action
of a menu item to a standard action, you can set the `selector` attribute of the
menu item.
### Main menu's name
On OS X the label of application menu's first item is always your app's name,
no matter what label you set. To change it you have to change your app's name
by modifying your app bundle's `Info.plist` file. See
[About Information Property List Files](https://developer.apple.com/library/ios/documentation/general/Reference/InfoPlistKeyReference/Articles/AboutInformationPropertyListFiles.html)
for more.
## Menu item position
You can make use of `position` and `id` to control how the item would be placed
when building a menu with `Menu.buildFromTemplate`.
The `position` attribute of `MenuItem` has the form `[placement]=[id]` where
placement is one of `before`, `after`, or `endof` and `id` is the unique ID of
an existing item in the menu:
* `before` - Inserts this item before the id referenced item. If the
referenced item doesn't exist the item will be inserted at the end of
the menu.
* `after` - Inserts this item after id referenced item. If the referenced
item doesn't exist the item will be inserted at the end of the menu.
* `endof` - Inserts this item at the end of the logical group containing
the id referenced item. (Groups are created by separator items). If
the referenced item doesn't exist a new separator group is created with
the given id and this item is inserted after that separator.
When an item is positioned following unpositioned items are inserted after
it, until a new item is positioned. So if you want to position a group of
menu items in the same location you only need to specify a position for
the first item.
### Examples
Template:
```javascript
[
{label: '4', id: '4'},
{label: '5', id: '5'},
{label: '1', id: '1', position: 'before=4'},
{label: '2', id: '2'},
{label: '3', id: '3'}
]
```
Menu:
```
- 1
- 2
- 3
- 4
- 5
```
Template:
```javascript
[
{label: 'a', position: 'endof=letters'},
{label: '1', position: 'endof=numbers'},
{label: 'b', position: 'endof=letters'},
{label: '2', position: 'endof=numbers'},
{label: 'c', position: 'endof=letters'},
{label: '3', position: 'endof=numbers'}
]
```
Menu:
```
- ---
- a
- b
- c
- ---
- 1
- 2
- 3
```

127
docs/api/native-image-ko.md Normal file
View file

@ -0,0 +1,127 @@
# NativeImage
Electron은 파일 경로나 `NativeImage` 인스턴스를 전달하여 사용하는 이미지 API를 가지고 있습니다. `null`을 전달할 경우 빈 이미지가 사용됩니다.
예를 들어 트레이 메뉴를 만들거나 윈도우의 아이콘을 설정할 때 다음과 같이 `문자열`인 파일 경로를 전달할 수 있습니다:
```javascript
var appIcon = new Tray('/Users/somebody/images/icon.png');
var window = new BrowserWindow({icon: '/Users/somebody/images/window.png'});
```
또는 클립보드로부터 이미지를 읽어올 수 있습니다:
```javascript
var clipboard = require('clipboard');
var image = clipboard.readImage();
var appIcon = new Tray(image);
```
## 지원하는 포맷
현재 `PNG` 와 `JPEG` 포맷을 지원하고 있습니다. 손실 없는 이미지 압축과 투명도 지원을 위해 `PNG` 사용을 권장합니다.
## 고해상도 이미지
플랫폼이 high-DPI를 지원하는 경우 `@2x`와 같이 이미지의 파일명 뒤에 접미사를 추가하여 고해상도 이미지로 지정할 수 있습니다.
예를 들어 `icon.png` 라는 기본 해상도의 이미지를 기준으로 크기를 두 배로 늘린 이미지를 `icon@2x.png`와 같이 이름을 지정하면 고해상도 이미지로 처리됩니다.
서로 다른 해상도(DPI)의 이미지를 지원하고 싶다면 다중 해상도의 이미지를 접미사를 붙여 한 폴더에 넣으면 됩니다. 이 이미지를 사용(로드)할 땐 접미사를 붙이지 않습니다:
```text
images/
├── icon.png
├── icon@2x.png
└── icon@3x.png
```
```javascript
var appIcon = new Tray('/Users/somebody/images/icon.png');
```
지원하는 DPI 접미사는 다음과 같습니다:
* `@1x`
* `@1.25x`
* `@1.33x`
* `@1.4x`
* `@1.5x`
* `@1.8x`
* `@2x`
* `@2.5x`
* `@3x`
* `@4x`
* `@5x`
## 템플릿 이미지
템플릿 이미지는 검은색과 명확한 색상(알파 채널)으로 이루어져 있습니다.
템플릿 이미지는 단독 이미지로 사용되지 않고 다른 컨텐츠와 혼합되어 최종 외관 만드는데 사용됩니다.
가장 일반적으로 템플릿 이미지는 밝고 어두운 테마 색상으로 변경할 수 있는 메뉴 바 아이콘 등에 사용되고 있습니다.
템플릿 이미지는 Mac 운영체제만 지원합니다.
템플릿 이미지를 지정하려면 다음 예제와 같이 파일명에 `Template` 문자열을 추가해야 합니다:
* `xxxTemplate.png`
* `xxxTemplate@2x.png`
## nativeImage.createEmpty()
빈 `NativeImage` 인스턴스를 만듭니다.
## nativeImage.createFromPath(path)
* `path` String
`path`로부터 이미지를 로드하여 새로운 `NativeImage` 인스턴스를 만듭니다.
## nativeImage.createFromBuffer(buffer[, scaleFactor])
* `buffer` [Buffer][buffer]
* `scaleFactor` Double
`buffer`로부터 이미지를 로드하여 새로운 `NativeImage` 인스턴스를 만듭니다. `scaleFactor`는 1.0이 기본입니다.
## nativeImage.createFromDataUrl(dataUrl)
* `dataUrl` String
`dataUrl`로부터 이미지를 로드하여 새로운 `NativeImage` 인스턴스를 만듭니다.
## Class: NativeImage
이미지를 표현한 클래스입니다.
### NativeImage.toPng()
`PNG` 이미지를 인코딩한 데이터를 [Buffer][buffer]로 반환합니다.
### NativeImage.toJpeg(quality)
* `quality` Integer
`JPEG` 이미지를 인코딩한 데이터를 [Buffer][buffer]로 반환합니다.
### NativeImage.toDataUrl()
이미지의 data URL을 반환합니다.
### NativeImage.isEmpty()
이미지가 비었는지를 체크합니다.
### NativeImage.getSize()
이미지의 사이즈를 반환합니다.
### NativeImage.setTemplateImage(option)
* `option` Boolean
해당 이미지를 템플릿 이미지로 설정합니다.
[buffer]: https://iojs.org/api/buffer.html#buffer_class_buffer

2
docs/api/power-monitor-ko.md
View file

@ -1,4 +1,4 @@
# power-monitor
# power-monitor
`power-monitor` 모듈은 PC의 파워 상태를 나타냅니다. (주로 노트북 등에서 사용됩니다)
이 모듈은 메인 프로세스에서만 사용할 수 있으며, (remote 모듈(RPC)을 사용해도 작동이 됩니다)

43
docs/api/power-save-blocker-ko.md Normal file
View file

@ -0,0 +1,43 @@
# power-save-blocker
`power-save-blocker` 모듈은 시스템이 저전력 모드(슬립)로 진입하는 것을 막고 앱 및 화면이 항상 활성화되어 있는 상태를 만들 수 있도록 해줍니다.
예제:
```javascript
var powerSaveBlocker = require('power-save-blocker');
var id = powerSaveBlocker.start('prevent-display-sleep');
console.log(powerSaveBlocker.isStarted(id));
powerSaveBlocker.stop(id);
```
## powerSaveBlocker.start(type)
* `type` String - Power save blocker 종류
* `prevent-app-suspension` - 저전력 모드 등으로 인한 어플리케이션 작동 중단을 방지합니다.
시스템을 항시 활성화 상태로 만듭니다, 하지만 화면은 자동으로 꺼질 수 있습니다. 사용 예시: 파일 다운로드, 음악 재생 등.
* `prevent-display-sleep`- 슬립 모드 등으로 인한 어플리케이션의 작동 중단을 방지합니다.
시스템을 항시 활성화 상태로 만들고 슬립 모드(화면 꺼짐)를 방지합니다. 사용 예시: 비디오 재생 등.
Power save blocker를 시작하고 시스템이 저전력 모드(슬립)로 진입하는 것을 막습니다. 정수로 된 식별 ID를 반환합니다.
**알림:**
`prevent-display-sleep` 모드는 `prevent-app-suspension` 보다 우선순위가 높습니다.
가장 높은 우선순위의 모드만 작동합니다. 다시 말해 `prevent-display-sleep` 모드는 언제나 `prevent-app-suspension` 모드의 효과를 덮어씌웁니다.
예를 들어 A-요청이 `prevent-app-suspension` 모드를 사용하고 B-요청이 `prevent-display-sleep`를 사용하는 API 호출이 있었다 치면
`prevent-display-sleep` 모드를 사용하는 B의 작동이 중단(stop)되기 전까지 작동하다 B가 중단되면 `prevent-app-suspension` 모드를 사용하는 A가 작동하기 시작합니다.
## powerSaveBlocker.stop(id)
* `id` Integer - `powerSaveBlocker.start`로 부터 반환되는 power save blocker 식별 ID.
설정한 power save blocker를 중지합니다.
## powerSaveBlocker.isStarted(id)
* `id` Integer - `powerSaveBlocker.start`로 부터 반환되는 power save blocker 식별 ID.
해당하는 id의 `powerSaveBlocker`가 실행중인지 확인합니다.

12
docs/api/process-ko.md Normal file
View file

@ -0,0 +1,12 @@
# 프로세스 객체
Electron의 `process` 객체는 기존의 node와는 달리 약간의 차이점이 있습니다:
* `process.type` String - 프로세스의 타입, `browser` (메인 프로세스) 또는 `renderer`가 됩니다.
* `process.versions['electron']` String - Electron의 버전.
* `process.versions['chrome']` String - Chromium의 버전.
* `process.resourcesPath` String - JavaScript 소스코드의 경로.
## process.hang
현재 프로세스의 주 스레드를 중단시킵니다.

114
docs/api/protocol-ko.md Normal file
View file

@ -0,0 +1,114 @@
# protocol
`protocol` 모듈은 여러 프로토콜의 요청과 응답을 커스터마이즈 할 수 있도록 이미 있는 프로토콜을 변경하거나 새로운 프로토콜을 만드는 방법을 제공합니다.
다음 예제는 `file://` 프로토콜과 같은 일을 하는 커스텀 프로토콜을 설정합니다:
```javascript
var app = require('app');
var path = require('path');
app.on('ready', function() {
var protocol = require('protocol');
protocol.registerProtocol('atom', function(request) {
var url = request.url.substr(7)
return new protocol.RequestFileJob(path.normalize(__dirname + '/' + url));
});
});
```
**알림:** 이 모듈은 app의 `ready` 이벤트가 발생한 이후에만 사용할 수 있습니다.
## protocol.registerProtocol(scheme, handler)
* `scheme` String
* `handler` Function
지정한 `scheme`을 기반으로 커스텀 프로토콜을 등록합니다. 등록한 `scheme` 프로토콜에 요청이 들어올 경우 `request` 인자와 함께 `handler` 함수가 호출됩니다.
호출된 `handler` 함수에선 요청에 대한 해당 프로토콜의 작업 결과를 응답(반환) 해야 할 필요가 있습니다.
## protocol.unregisterProtocol(scheme)
* `scheme` String
지정한 `scheme` 프로토콜을 등록 해제합니다.
## protocol.registerStandardSchemes(value)
* `value` Array
지정한 `value` 배열을 사용하여 미리 지정된 스킴으로 등록합니다.
## protocol.isHandledProtocol(scheme)
* `scheme` String
해당 `scheme`에 처리자(handler)가 등록되었는지 확인합니다.
## protocol.interceptProtocol(scheme, handler)
* `scheme` String
* `handler` Function
지정한 `scheme`의 작업을 `handler`로 변경합니다.
`handler`에서 `null` 또는 `undefined`를 반환 할 경우 해당 프로토콜의 기본 동작(응답)으로 대체 됩니다.
## protocol.uninterceptProtocol(scheme)
* `scheme` String
변경된 프로토콜의 작업을 해제합니다.
## Class: protocol.RequestFileJob(path)
* `path` String
`path` 경로를 기반으로 파일을 반환하는 request 작업을 생성합니다. 그리고 해당 파일에 상응하는 mime type을 지정합니다.
## Class: protocol.RequestStringJob(options)
* `options` Object
* `mimeType` String - `text/plain`이 기본
* `charset` String - `UTF-8`이 기본
* `data` String
문자열을 반환하는 request 작업을 생성합니다.
## Class: protocol.RequestBufferJob(options)
* `options` Object
* `mimeType` String - Default is `application/octet-stream`
* `encoding` String - Default is `UTF-8`
* `data` Buffer
버퍼를 반환하는 request 작업을 생성합니다.
## Class: protocol.RequestHttpJob(options)
* `options` Object
* `url` String
* `method` String - Default is `GET`
* `referrer` String
`url`의 요청 결과를 그대로 반환하는 request 작업을 생성합니다.
## Class: protocol.RequestErrorJob(code)
* `code` Integer
콘솔에 특정한 네트워크 에러 메시지를 설정하는 request 작업을 생성합니다.
기본 메시지는 `net::ERR_NOT_IMPLEMENTED`입니다. 사용할 수 있는 코드의 범위는 다음과 같습니다.
* 범위:
* 0- 99 System related errors
* 100-199 Connection related errors
* 200-299 Certificate errors
* 300-399 HTTP errors
* 400-499 Cache errors
* 500-599 ?
* 600-699 FTP errors
* 700-799 Certificate manager errors
* 800-899 DNS resolver errors
에러 코드와 메시지에 대해 자세하게 알아보려면 [네트워크 에러 리스트](https://code.google.com/p/chromium/codesearch#chromium/src/net/base/net_error_list.h)를 참고하기 바랍니다.

159
docs/api/remote-ko.md Normal file
View file

@ -0,0 +1,159 @@
# remote
The `remote` module provides a simple way to do inter-process communication
between the renderer process and the main process.
In Electron, only GUI-unrelated modules are available in the renderer process.
Without the `remote` module, users who wanted to call a main process API in
the renderer process would have to explicitly send inter-process messages
to the main process. With the `remote` module, users can invoke methods of
main process object without explicitly sending inter-process messages,
similar to Java's
[RMI](http://en.wikipedia.org/wiki/Java_remote_method_invocation).
An example of creating a browser window in renderer process:
```javascript
var remote = require('remote');
var BrowserWindow = remote.require('browser-window');
var win = new BrowserWindow({ width: 800, height: 600 });
win.loadUrl('https://github.com');
```
Note: for the reverse (access renderer process from main process), you can use [webContents.executeJavascript](https://github.com/atom/electron/blob/master/docs/api/browser-window-ko.md#browserwindowwebcontents).
## Remote objects
Each object (including functions) returned by the `remote` module represents an
object in the main process (we call it a remote object or remote function).
When you invoke methods of a remote object, call a remote function, or create
a new object with the remote constructor (function), you are actually sending
synchronous inter-process messages.
In the example above, both `BrowserWindow` and `win` were remote objects and
`new BrowserWindow` didn't create a `BrowserWindow` object in the renderer process.
Instead, it created a `BrowserWindow` object in the main process and returned the
corresponding remote object in the renderer process, namely the `win` object.
## Lifetime of remote objects
Electron makes sure that as long as the remote object in the renderer process
lives (in other words, has not been garbage collected), the corresponding object
in the main process would never be released. When the remote object has been
garbage collected, the corresponding object in the main process would be
dereferenced.
If the remote object is leaked in renderer process (e.g. stored in a map but never
freed), the corresponding object in the main process would also be leaked,
so you should be very careful not to leak remote objects.
Primary value types like strings and numbers, however, are sent by copy.
## Passing callbacks to the main process
Some APIs in the main process accept callbacks, and it would be tempting to
pass callbacks when calling a remote function. The `remote` module does support
doing this, but you should also be extremely careful with this.
First, in order to avoid deadlocks, the callbacks passed to the main process
are called asynchronously, so you should not expect the main process to
get the return value of the passed callbacks.
Second, the callbacks passed to the main process will not get released
automatically after they are called. Instead, they will persistent until the
main process garbage-collects them.
For example, the following code seems innocent at first glance. It installs a
callback for the `close` event on a remote object:
```javascript
var remote = require('remote');
remote.getCurrentWindow().on('close', function() {
// blabla...
});
```
The problem is that the callback would be stored in the main process until you
explicitly uninstall it! So each time you reload your window, the callback would
be installed again and previous callbacks would just leak. To make things
worse, since the context of previously installed callbacks have been released,
when the `close` event was emitted, exceptions would be raised in the main process.
Generally, unless you are clear what you are doing, you should always avoid
passing callbacks to the main process.
## Remote buffer
An instance of node's `Buffer` is an object, so when you get a `Buffer` from
the main process, what you get is indeed a remote object (let's call it remote
buffer), and everything would just follow the rules of remote objects.
However you should remember that although a remote buffer behaves like the real
`Buffer`, it's not a `Buffer` at all. If you pass a remote buffer to node APIs
that accept a `Buffer`, you should assume the remote buffer would be treated
like a normal object, instead of a `Buffer`.
For example, you can call `BrowserWindow.capturePage` in the renderer process, which
returns a `Buffer` by calling the passed callback:
```javascript
var remote = require('remote');
var fs = require('fs');
remote.getCurrentWindow().capturePage(function(image) {
var buf = image.toPng();
fs.writeFile('/tmp/screenshot.png', buf, function(err) {
console.log(err);
});
});
```
But you may be surprised to find that the file written was corrupted. This is
because when you called `fs.writeFile`, thinking that `buf` was a `Buffer` when
in fact it was a remote buffer, and it was converted to string before it was
written to the file. Since `buf` contained binary data and could not be represented
by a UTF-8 encoded string, the written file was corrupted.
The work-around is to write the `buf` in the main process, where it is a real
`Buffer`:
```javascript
var remote = require('remote');
remote.getCurrentWindow().capturePage(function(image) {
var buf = image.toPng();
remote.require('fs').writeFile('/tmp/screenshot.png', buf, function(err) {
console.log(err);
});
});
```
The same thing could happen for all native types, but usually it would just
throw a type error. The `Buffer` deserves your special attention because it
might be converted to string, and APIs accepting `Buffer` usually accept string
too, and data corruption could happen when it contains binary data.
## remote.require(module)
* `module` String
Returns the object returned by `require(module)` in the main process.
## remote.getCurrentWindow()
Returns the [BrowserWindow](browser-window-ko.md) object which this web page
belongs to.
## remote.getCurrentWebContent()
Returns the WebContents object of this web page.
## remote.getGlobal(name)
* `name` String
Returns the global variable of `name` (e.g. `global[name]`) in the main
process.
## remote.process
Returns the `process` object in the main process. This is the same as
`remote.getGlobal('process')`, but gets cached.

105
docs/api/screen-ko.md Normal file
View file

@ -0,0 +1,105 @@
# screen
Gets various info about screen size, displays, cursor position, etc. You should
not use this module until the `ready` event of `app` module gets emitted.
`screen` is an [EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter).
Make sure to note that in the renderer / DevTools, `window.screen` is a reserved DOM property, so writing `screen = require('screen')` won't work. In our examples below, we use `atomScreen` as the variable name instead.
An example of creating a window that fills the whole screen:
```javascript
var app = require('app');
var BrowserWindow = require('browser-window');
var mainWindow;
app.on('ready', function() {
var atomScreen = require('screen');
var size = atomScreen.getPrimaryDisplay().workAreaSize;
mainWindow = new BrowserWindow({ width: size.width, height: size.height });
});
```
Another example of creating a window in the external display:
```javascript
var app = require('app');
var BrowserWindow = require('browser-window');
var mainWindow;
app.on('ready', function() {
var atomScreen = require('screen');
var displays = atomScreen.getAllDisplays();
var externalDisplay = null;
for (var i in displays) {
if (displays[i].bounds.x > 0 || displays[i].bounds.y > 0) {
externalDisplay = displays[i];
break;
}
}
if (externalDisplay) {
mainWindow = new BrowserWindow({
x: externalDisplay.bounds.x + 50,
y: externalDisplay.bounds.y + 50,
});
}
});
```
## Event: display-added
* `event` Event
* `newDisplay` Object
Emitted when `newDisplay` has been added.
## Event: display-removed
* `event` Event
* `oldDisplay` Object
Emitted when `oldDisplay` has been removed.
## Event: display-metrics-changed
* `event` Event
* `display` Object
* `changedMetrics` Array
Emitted when a `display` has one or more metrics changed, `changedMetrics` is
an array of strings that describe the changes. Possible changes are `bounds`,
`workArea`, `scaleFactor` and `rotation`.
## screen.getCursorScreenPoint()
Returns the current absolute position of the mouse pointer.
## screen.getPrimaryDisplay()
Returns the primary display.
## screen.getAllDisplays()
Returns an array of displays that are currently available.
## screen.getDisplayNearestPoint(point)
* `point` Object
* `x` Integer
* `y` Integer
Returns the display nearest the specified point.
## screen.getDisplayMatching(rect)
* `rect` Object
* `x` Integer
* `y` Integer
* `width` Integer
* `height` Integer
Returns the display that most closely intersects the provided bounds.

41
docs/api/shell-ko.md Normal file
View file

@ -0,0 +1,41 @@
# shell
`shell` 모듈은 데스크톱 환경 통합에 관련하여 제공되는 모듈입니다.
다음 예제는 기본 브라우저로 설정된 URL을 엽니다:
```javascript
var shell = require('shell');
shell.openExternal('https://github.com');
```
## shell.showItemInFolder(fullPath)
* `fullPath` String
지정한 파일을 탐색기에서 보여줍니다. 가능한 경우 탐색기 내에서 파일을 선택합니다.
## shell.openItem(fullPath)
* `fullPath` String
지정한 파일을 데스크톱 기본 프로그램으로 엽니다.
## shell.openExternal(url)
* `url` String
제공된 외부 프로토콜 URL을 기반으로 데스크톱의 기본 프로그램으로 엽니다. (예를들어 mailto: URL은 해당 URL을 기본 메일 에이전트로 엽니다.)
역자주: 폴더는 'file:\\\\C:\\'와 같이 지정하여 열 수 있습니다. (`\\`로 경로를 표현한 이유는 Escape 문자열을 참고하세요.)
## shell.moveItemToTrash(fullPath)
* `fullPath` String
Move the given file to trash and returns boolean status for the operation.
지정한 파일을 휴지통으로 이동합니다. 작업의 성공여부를 boolean 형으로 리턴합니다.
## shell.beep()
비프음을 재생합니다.

39
docs/api/synopsis-ko.md Normal file
View file

@ -0,0 +1,39 @@
# 개요
Electron은 모든 [node.js's built-in 모듈](http://nodejs.org/api/)과 third-party node 모듈을 완벽하게 지원합니다. ([네이티브 모듈](../tutorial/using-native-node-modules-ko.md)을 포함해서)
Electron은 네이티브 데스크톱 어플리케이션을 개발 할 수 있도록 추가적인 built-in 모듈을 제공합니다.
몇몇 모듈은 메인 프로세스에서만 사용할 수 있고 어떤 모듈은 랜더러 프로세스에서만 사용할 수 있습니다. 또한 두 프로세스 모두 사용할 수 있는 모듈도 있습니다.
기본적인 규칙은 다음과 같습니다: GUI와 저 수준 시스템에 관련된 모듈은 오직 메인 프로세스에서만 사용할 수 있습니다.
[메인 프로세스 vs. 랜더러 프로세스](../tutorial/quick-start-ko.md#메인 프로세스) 컨셉에 익숙해야 이 모듈들을 사용하기 쉬우므로 해당 문서를 정독하는 것을 권장합니다.
메인 프로세스 스크립트는 일반 `node.js` 스크립트와 같습니다:
```javascript
var app = require('app');
var BrowserWindow = require('browser-window');
var window = null;
app.on('ready', function() {
window = new BrowserWindow({width: 800, height: 600});
window.loadUrl('https://github.com');
});
```
웹 페이지 역시 예외적인 node module을 사용할 수 있다는 점을 제외하면 일반 웹 페이지와 다를게 없습니다:
```html
<!DOCTYPE html>
<html>
<body>
<script>
var remote = require('remote');
console.log(remote.require('app').getVersion());
</script>
</body>
</html>
```
어플리케이션을 실행하려면 [앱 실행하기](../tutorial/quick-start-ko.md#앱 실행하기) 문서를 참고하기 바랍니다.

2
docs/api/tray-ko.md
View file

@ -1,4 +1,4 @@
# Tray
# Tray
`Tray`는 OS의 알림영역에 아이콘을 표시합니다. 보통 컨텍스트 메뉴(context menu)를 같이 사용합니다.

61
docs/api/web-frame-ko.md Normal file
View file

@ -0,0 +1,61 @@
# web-frame
`web-frame` 모듈은 현재 웹 페이지의 랜더링 상태를 커스터마이즈 할 수 있도록 해줍니다.
다음 예제는 현재 페이지를 200% 줌 합니다.
```javascript
var webFrame = require('web-frame');
webFrame.setZoomFactor(2);
```
## webFrame.setZoomFactor(factor)
* `factor` Number - Zoom 값
지정한 값으로 페이지를 줌 합니다. 줌 값은 퍼센트 / 100입니다. (예시: 300% = 3.0)
## webFrame.getZoomFactor()
현재 줌 값을 반환합니다.
## webFrame.setZoomLevel(level)
* `level` Number - Zoom level
지정한 레벨로 줌 레벨을 변경합니다. 0은 "기본 크기" 입니다.
그리고 각각 레벨 값을 올리거나 내릴 때마다 20%씩 커지거나 작아지고 기본 크기의 50%부터 300%까지 조절 제한이 있습니다.
## webFrame.getZoomLevel()
현재 줌 레벨을 반환합니다.
## webFrame.setSpellCheckProvider(language, autoCorrectWord, provider)
* `language` String
* `autoCorrectWord` Boolean
* `provider` Object
Input field나 text area에 철자 검사(spell checking) 제공자를 설정합니다.
`provider`는 반드시 전달된 단어의 철자가 맞았는지 검사하는 `spellCheck` 메소드를 가지고 있어야 합니다.
[node-spellchecker][spellchecker]를 철자 검사 제공자로 사용하는 예제입니다:
```javascript
require('web-frame').setSpellCheckProvider("en-US", true, {
spellCheck: function(text) {
return !(require('spellchecker').isMisspelled(text));
}
});
```
## webFrame.registerUrlSchemeAsSecure(scheme)
* `scheme` String
지정한 `scheme`을 보안 스킴으로 설정합니다.
보안 스킴은 혼합된 컨텐츠 경고를 발생시키지 않습니다. 예를 들어 `https` 와 `data`는 네트워크 공격자로부터 손상될 가능성이 없기 때문에 보안 스킴입니다.
[spellchecker]: https://github.com/atom/node-spellchecker

8
docs/api/web-view-tag-ko.md
View file

@ -1,4 +1,4 @@
# `<webview>` 태그
# `<webview>` 태그
Use the `webview` tag to embed 'guest' content (such as web pages) in your
Electron app. The guest content is contained within the `webview` container;
@ -10,7 +10,7 @@ app; it doesn't have the same permissions as your web page and all interactions
between your app and embedded content will be asynchronous. This keeps your app
safe from the embedded content.
## 예제
## 예제
To embed a web page in your app, add the `webview` tag to your app's embedder
page (this is the app page that will display the guest content). In its simplest
@ -45,7 +45,7 @@ and displays a "loading..." message during the load time:
</script>
```
## 태그 속성
## 태그 속성
### src
@ -308,7 +308,7 @@ page can handle it by listening to the `channel` event of `ipc` module.
See [WebContents.send](browser-window-ko.md#webcontentssendchannel-args) for
examples.
## DOM 이벤트
## DOM 이벤트
### did-finish-load

57
docs/api/window-open-ko.md Normal file
View file

@ -0,0 +1,57 @@
# `window.open` 함수
`window.open` 함수가 호출되면 새 창에서 새로운 페이지를 불러옵니다.
이 창은 `url`로 부터 만들어진 `BrowserWindow`의 새 인스턴스이며 본 객체 대신 페이지의 컨트롤이 제한된 프록시 객체를 반환합니다.
프록시 객체는 기존의 웹 페이지와 호환될 수 있도록 일부 제한된 표준 기능만 가지고 있습니다.
창의 모든 컨트롤을 가지려면 `BrowserWindow`를 직접 생성하여 작업해야 합니다.
## window.open(url, [frameName[, features]])
* `url` String
* `frameName` String
* `features` String
`BrowserWindowProxy` 클래스의 객체를 반환하는 새로운 윈도우를 생성합니다.
## window.opener.postMessage(message, targetOrigin)
* `message` String
* `targetOrigin` String
부모 윈도우에 메시지를 보냅니다. 특정한 origin을 지정할 수도 있으며 `*`를 지정하면 따로 origin 설정을 사용하지 않습니다.
## Class: BrowserWindowProxy
### BrowserWindowProxy.blur()
자식 윈도우의 포커스를 해제합니다.
### BrowserWindowProxy.close()
자식 윈도우를 강제로 닫습니다. unload 이벤트가 발생하지 않습니다.
Forcefully closes the child window without calling its unload event.
### BrowserWindowProxy.closed
자식 윈도우가 닫히면 true로 설정됩니다.
### BrowserWindowProxy.eval(code)
* `code` String
자식 윈도우에서 특정 스크립트를 실행합니다.
### BrowserWindowProxy.focus()
자식 윈도우에 포커스를 맞춥니다. (창을 맨 앞으로 가져옵니다)
### BrowserWindowProxy.postMessage(message, targetOrigin)
* `message` String
* `targetOrigin` String
자식 윈도우에 메시지를 보냅니다. 특정한 origin을 지정할 수도 있으며 `*`를 지정하면 따로 origin 설정을 사용하지 않습니다.
참고로 자식 윈도우의 `window.opener` 객체에는 다른 속성 없이 이 함수 하나만 구현되어 있습니다.