Fix typos, add more files

2015-06-26 02:32:51 +09:00 · 2015-06-26 02:32:51 +09:00 · ebb031dafe
commit ebb031dafe
parent bf5b084945
45 changed files with 3450 additions and 239 deletions
--- a/docs/api/accelerator-ko.md
+++ b/docs/api/accelerator-ko.md
@ -1,4 +1,4 @@
-# Accelerator
+# Accelerator

 Accelerator는 키보드 단축키를 표현하는 문자열입니다, 여러 혼합키와 키코드를 `+` 문자를
 이용하여 결합할 수 있습니다.
--- a/docs/api/app-ko.md
+++ b/docs/api/app-ko.md
@ -0,0 +1,289 @@
+# 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.md) gets blurred.
+
+## Event: browser-window-focus
+
+* `event` Event
+* `window` BrowserWindow
+
+Emitted when a [browserWindow](browser-window.md) gets focused.
+
+## 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
--- a/docs/api/auto-updater-ko.md
+++ b/docs/api/auto-updater-ko.md
@ -0,0 +1,143 @@
+# auto-updater
+
+**This module has only been implemented for OS X.**
+
+Check out [atom/grunt-atom-shell-installer](https://github.com/atom/grunt-atom-shell-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.
--- a/docs/api/browser-window-ko.md
+++ b/docs/api/browser-window-ko.md
--- a/docs/api/chrome-command-line-switches-ko.md
+++ b/docs/api/chrome-command-line-switches-ko.md
@ -0,0 +1,109 @@
+# Supported Chrome command line switches
+
+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.md
+[append-switch]: app.md#appcommandlineappendswitchswitch-value
+[ready]: app.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');
+```
--- a/docs/api/clipboard-ko.md
+++ b/docs/api/clipboard-ko.md
@ -0,0 +1,90 @@
+# clipboard
+
+The `clipboard` provides methods to do copy/paste operations. An example of
+writing a string to clipboard:
+
+```javascript
+var clipboard = require('clipboard');
+clipboard.writeText('Example String');
+```
+
+On X Window systems, there is also a selection clipboard, to manipulate in it
+you need to pass `selection` to each method:
+
+```javascript
+var clipboard = require('clipboard');
+clipboard.writeText('Example String', 'selection');
+console.log(clipboard.readText('selection'));
+```
+
+## clipboard.readText([type])
+
+* `type` String
+
+Returns the content in clipboard as plain text.
+
+## clipboard.writeText(text[, type])
+
+* `text` String
+* `type` String
+
+Writes the `text` into clipboard as plain text.
+
+## clipboard.readHtml([type])
+
+* `type` String
+
+Returns the content in clipboard as markup.
+
+## clipboard.writeHtml(markup[, type])
+
+* `markup` String
+* `type` String
+
+Writes the `markup` into clipboard.
+
+## clipboard.readImage([type])
+
+* `type` String
+
+Returns the content in clipboard as [NativeImage](native-image.md).
+
+## clipboard.writeImage(image[, type])
+
+* `image` [NativeImage](native-image.md)
+* `type` String
+
+Writes the `image` into clipboard.
+
+## clipboard.clear([type])
+
+* `type` String
+
+Clears everything in clipboard.
+
+## clipboard.availableFormats([type])
+
+Returns an array of supported `format` for the clipboard `type`.
+
+## clipboard.has(data[, type])
+
+* `data` String
+* `type` String
+
+Returns whether clipboard supports the format of specified `data`.
+
+```javascript
+var clipboard = require('clipboard');
+console.log(clipboard.has('<p>selection</p>'));
+```
+
+**Note:** This API is experimental and could be removed in future.
+
+## clipboard.read(data[, type])
+
+* `data` String
+* `type` String
+
+Reads the `data` in clipboard.
+
+**Note:** This API is experimental and could be removed in future.
--- a/docs/api/content-tracing-ko.md
+++ b/docs/api/content-tracing-ko.md
@ -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.
--- a/docs/api/crash-reporter-ko.md
+++ b/docs/api/crash-reporter-ko.md
@ -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
--- a/docs/api/dialog-ko.md
+++ b/docs/api/dialog-ko.md
@ -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.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.
--- a/docs/api/file-object-ko.md
+++ b/docs/api/file-object-ko.md
@ -0,0 +1,30 @@
+# `File` object
+
+The DOM's File interface provides abstraction around native files, in order to
+let users work on native files directly with HTML5 file API, Electron has
+added a `path` attribute to `File` interface which exposes the file's real path
+on filesystem.
+
+Example on getting real path of a dragged file:
+
+```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>
+```
--- a/docs/api/frameless-window-ko.md
+++ b/docs/api/frameless-window-ko.md
@ -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.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.
--- a/docs/api/global-shortcut-ko.md
+++ b/docs/api/global-shortcut-ko.md
@ -0,0 +1,49 @@
+# global-shortcut
+
+The `global-shortcut` module can register/unregister a global keyboard shortcut
+in operating system, so that you can customize the operations for various shortcuts.
+Note that the shortcut is global, even if the app does not get focused, it will still work.
+
+```javascript
+var globalShortcut = require('global-shortcut');
+
+// Register a 'ctrl+x' shortcut listener.
+var ret = globalShortcut.register('ctrl+x', function() { console.log('ctrl+x is pressed'); })
+
+if (!ret) {
+  console.log('registration failed');
+}
+
+// Check whether a shortcut is registered.
+console.log(globalShortcut.isRegistered('ctrl+x'));
+
+// Unregister a shortcut.
+globalShortcut.unregister('ctrl+x');
+
+// Unregister all shortcuts.
+globalShortcut.unregisterAll();
+```
+
+## globalShortcut.register(accelerator, callback)
+
+* `accelerator` [Accelerator](accelerator.md)
+* `callback` Function
+
+Registers a global shortcut of `accelerator`, the `callback` would be called when
+the registered shortcut is pressed by user.
+
+## globalShortcut.isRegistered(accelerator)
+
+* `accelerator` [Accelerator](accelerator.md)
+
+Returns `true` or `false` depending on if the shortcut `accelerator` is registered.
+
+## globalShortcut.unregister(accelerator)
+
+* `accelerator` [Accelerator](accelerator.md)
+
+Unregisters the global shortcut of `keycode`.
+
+## globalShortcut.unregisterAll()
+
+Unregisters all the global shortcuts.
--- a/docs/api/ipc-main-process-ko.md
+++ b/docs/api/ipc-main-process-ko.md
@ -0,0 +1,49 @@
+# ipc (main process)
+
+Handles asynchronous and synchronous message sent from a renderer process (web
+page).
+
+The messages sent from a renderer would be emitted to this module, the event name
+is the `channel` when sending message. To reply a synchronous message, you need
+to set `event.returnValue`, to send an asynchronous back to the sender, you can
+use `event.sender.send(...)`.
+
+It's also possible to send messages from main process to the renderer process,
+see [WebContents.send](browser-window.md#webcontentssendchannel-args) for more.
+
+An example of sending and handling messages:
+
+```javascript
+// In main process.
+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
+// In renderer process (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
+
+Assign to this to return an value to synchronous messages.
+
+### Event.sender
+
+The `WebContents` that sent the message.
--- a/docs/api/ipc-renderer-ko.md
+++ b/docs/api/ipc-renderer-ko.md
@ -0,0 +1,29 @@
+# ipc (renderer)
+
+The `ipc` module provides a few methods so you can send synchronous and
+asynchronous messages to the main process, and also receive messages sent from
+main process. If you want to make use of modules of main process from renderer
+process, you might consider using the [remote](remote.md) module.
+
+See [ipc (main process)](ipc-main-process.md) for examples.
+
+## ipc.send(channel[, args...])
+
+Send `args..` to the renderer via `channel` in asynchronous message, the main
+process can handle it by listening to the `channel` event of `ipc` module.
+
+## ipc.sendSync(channel[, args...])
+
+Send `args..` to the renderer via `channel` in synchronous message, and returns
+the result sent from main process. The main process can handle it by listening to
+the `channel` event of `ipc` module, and returns by setting `event.returnValue`.
+
+**Note:** Usually developers should never use this API, since sending
+synchronous message would block the whole renderer process.
+
+## ipc.sendToHost(channel[, args...])
+
+Like `ipc.send` but the message will be sent to the host page instead of the
+main process.
+
+This is mainly used by the page in `<webview>` to communicate with host page.
--- a/docs/api/menu-item-ko.md
+++ b/docs/api/menu-item-ko.md
@ -1,13 +1,13 @@
-# 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)
@ -15,6 +15,6 @@
  * `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`를 이용하여 메뉴 아이템의 위치를 세밀하게 조정합니다.
--- a/docs/api/menu-ko.md
+++ b/docs/api/menu-ko.md
@ -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.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.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
+```
--- a/docs/api/native-image-ko.md
+++ b/docs/api/native-image-ko.md
@ -0,0 +1,139 @@
+# NativeImage
+
+In Electron for the APIs that take images, you can pass either file paths or
+`NativeImage` instances. When passing `null`, an empty image will be used.
+
+For example, when creating a tray or setting a window's icon, you can pass an image
+file path as a `String`:
+
+```javascript
+var appIcon = new Tray('/Users/somebody/images/icon.png');
+var window = new BrowserWindow({icon: '/Users/somebody/images/window.png'});
+```
+
+Or read the image from the clipboard:
+
+```javascript
+var clipboard = require('clipboard');
+var image = clipboard.readImage();
+var appIcon = new Tray(image);
+```
+
+## Supported formats
+
+Currently `PNG` and `JPEG` are supported. It is recommended to use `PNG`
+because of its support for transparency and lossless compression.
+
+## High resolution image
+
+On platforms that have high-DPI support, you can append `@2x` after image's
+file name's base name to mark it as a high resolution image.
+
+For example if `icon.png` is a normal image that has standard resolution, the
+`icon@2x.png` would be treated as a high resolution image that has double DPI
+density.
+
+If you want to support displays with different DPI density at the same time, you
+can put images with different sizes in the same folder, and use the filename
+without DPI suffixes, like this:
+
+```text
+images/
+├── icon.png
+├── icon@2x.png
+└── icon@3x.png
+```
+
+
+```javascript
+var appIcon = new Tray('/Users/somebody/images/icon.png');
+```
+
+Following suffixes as DPI denses are also supported:
+
+* `@1x`
+* `@1.25x`
+* `@1.33x`
+* `@1.4x`
+* `@1.5x`
+* `@1.8x`
+* `@2x`
+* `@2.5x`
+* `@3x`
+* `@4x`
+* `@5x`
+
+## Template image
+
+Template images consist of black and clear colors (and an alpha channel).
+Template images are not intended to be used as standalone images and are usually
+mixed with other content to create the desired final appearance.
+
+The most common case is to use template image for menu bar icon so it can adapt
+to both light and dark menu bars.
+
+Template image is only supported on Mac.
+
+To mark an image as template image, its filename should end with the word
+`Template`, examples are:
+
+* `xxxTemplate.png`
+* `xxxTemplate@2x.png`
+
+## nativeImage.createEmpty()
+
+Creates an empty `NativeImage` instance.
+
+## nativeImage.createFromPath(path)
+
+* `path` String
+
+Creates a new `NativeImage` instance from a file located at `path`.
+
+## nativeImage.createFromBuffer(buffer[, scaleFactor])
+
+* `buffer` [Buffer][buffer]
+* `scaleFactor` Double
+
+Creates a new `NativeImage` instance from `buffer`. The `scaleFactor` is 1.0 by
+default.
+
+## nativeImage.createFromDataUrl(dataUrl)
+
+* `dataUrl` String
+
+Creates a new `NativeImage` instance from `dataUrl`.
+
+## Class: NativeImage
+
+This class is used to represent an image.
+
+### NativeImage.toPng()
+
+Returns a [Buffer][buffer] that contains image's `PNG` encoded data.
+
+### NativeImage.toJpeg(quality)
+
+* `quality` Integer
+
+Returns a [Buffer][buffer] that contains image's `JPEG` encoded data.
+
+### NativeImage.toDataUrl()
+
+Returns the data URL of image.
+
+### NativeImage.isEmpty()
+
+Returns whether the image is empty.
+
+### NativeImage.getSize()
+
+Returns the size of the image.
+
+[buffer]: https://iojs.org/api/buffer.html#buffer_class_buffer
+
+### NativeImage.setTemplateImage(option)
+
+* `option` Boolean
+
+Marks the image as template image.
--- a/docs/api/power-monitor-ko.md
+++ b/docs/api/power-monitor-ko.md
@ -1,4 +1,4 @@
-# power-monitor
+# power-monitor

 `power-monitor` 모듈은 PC의 파워 상태를 나타냅니다. (주로 노트북 등에서 사용됩니다)
 이 모듈은 메인 프로세스에서만 사용할 수 있으며, (remote 모듈(RPC)을 사용해도 작동이 됩니다)
--- a/docs/api/process-ko.md
+++ b/docs/api/process-ko.md
@ -0,0 +1,13 @@
+# Process object
+
+The `process` object in Electron has the following differences from the one in
+upstream node:
+
+* `process.type` String - Process's type, can be `browser` (i.e. main process) or `renderer`.
+* `process.versions['electron']` String - Version of Electron.
+* `process.versions['chrome']` String - Version of Chromium.
+* `process.resourcesPath` String - Path to JavaScript source code.
+
+## process.hang
+
+Causes the main thread of the current process hang.
--- a/docs/api/protocol-ko.md
+++ b/docs/api/protocol-ko.md
@ -0,0 +1,121 @@
+# protocol
+
+The `protocol` module can register a new protocol or intercept an existing
+protocol, so you can customize the response to the requests for various protocols.
+
+An example of implementing a protocol that has the same effect with the
+`file://` protocol:
+
+```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));
+    });
+});
+```
+
+**Note:** This module can only be used after the `ready` event
+was emitted.
+
+## protocol.registerProtocol(scheme, handler)
+
+* `scheme` String
+* `handler` Function
+
+Registers a custom protocol of `scheme`, the `handler` would be called with
+`handler(request)` when the a request with registered `scheme` is made.
+
+You need to return a request job in the `handler` to specify which type of
+response you would like to send.
+
+## protocol.unregisterProtocol(scheme)
+
+* `scheme` String
+
+Unregisters the custom protocol of `scheme`.
+
+## protocol.registerStandardSchemes(value)
+
+* `value` Array
+
+`value` is an array of custom schemes to be registered to the standard.
+
+## protocol.isHandledProtocol(scheme)
+
+* `scheme` String
+
+Returns whether the `scheme` can be handled already.
+
+## protocol.interceptProtocol(scheme, handler)
+
+* `scheme` String
+* `handler` Function
+
+Intercepts an existing protocol with `scheme`, returning `null` or `undefined`
+in `handler` would use the original protocol handler to handle the request.
+
+## protocol.uninterceptProtocol(scheme)
+
+* `scheme` String
+
+Unintercepts a protocol.
+
+## Class: protocol.RequestFileJob(path)
+
+* `path` String
+
+Create a request job which would query a file of `path` and set corresponding
+mime types.
+
+## Class: protocol.RequestStringJob(options)
+
+* `options` Object
+  * `mimeType` String - Default is `text/plain`
+  * `charset` String - Default is `UTF-8`
+  * `data` String
+
+Create a request job which sends a string as response.
+
+## Class: protocol.RequestBufferJob(options)
+
+* `options` Object
+  * `mimeType` String - Default is `application/octet-stream`
+  * `encoding` String - Default is `UTF-8`
+  * `data` Buffer
+
+Create a request job which sends a buffer as response.
+
+## Class: protocol.RequestHttpJob(options)
+
+* `options` Object
+  * `url` String
+  * `method` String - Default is `GET`
+  * `referrer` String
+
+Send a request to `url` and pipe the response back.
+
+## Class: protocol.RequestErrorJob(code)
+
+* `code` Integer
+
+Create a request job which sets appropriate network error message to console.
+Default message is `net::ERR_NOT_IMPLEMENTED`. Code should be in the following
+range.
+
+* Ranges:
+  * 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
+
+Check the [network error list](https://code.google.com/p/chromium/codesearch#chromium/src/net/base/net_error_list.h) for code and message relations.
--- a/docs/api/remote-ko.md
+++ b/docs/api/remote-ko.md
@ -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.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.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.
--- a/docs/api/screen-ko.md
+++ b/docs/api/screen-ko.md
@ -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.
--- a/docs/api/shell-ko.md
+++ b/docs/api/shell-ko.md
@ -0,0 +1,39 @@
+# shell
+
+The `shell` module provides functions related to desktop integration.
+
+An example of opening a URL in default browser:
+
+```javascript
+var shell = require('shell');
+shell.openExternal('https://github.com');
+```
+
+## shell.showItemInFolder(fullPath)
+
+* `fullPath` String
+
+Show the given file in a file manager. If possible, select the file.
+
+## shell.openItem(fullPath)
+
+* `fullPath` String
+
+Open the given file in the desktop's default manner.
+
+## shell.openExternal(url)
+
+* `url` String
+
+Open the given external protocol URL in the desktop's default manner. (For
+example, mailto: URLs in the default mail user agent.)
+
+## shell.moveItemToTrash(fullPath)
+
+* `fullPath` String
+
+Move the given file to trash and returns boolean status for the operation.
+
+## shell.beep()
+
+Play the beep sound.
--- a/docs/api/synopsis-ko.md
+++ b/docs/api/synopsis-ko.md
@ -0,0 +1,44 @@
+# Synopsis
+
+All of [node.js's built-in modules](http://nodejs.org/api/) are available in
+Electron, and third-party node modules are fully supported too (including the
+[native modules](../tutorial/using-native-node-modules.md)).
+
+Electron also provides some extra built-in modules for developing native
+desktop applications. Some modules are only available on the main process, some
+are only available on the renderer process, and some can be used on both processes.
+The basic rule is: if a module is GUI or low-level system related, then it should
+be only available on the main process. You need to be familiar with the concept of
+[main process vs. renderer process](../tutorial/quick-start.md#the-main-process)
+scripts to be able to use those modules.
+
+The main process script is just like a normal `node.js` script:
+
+```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');
+});
+```
+
+The web page is no different than a normal web page, except for the extra
+ability to use node modules:
+
+```html
+<!DOCTYPE html>
+<html>
+  <body>
+    <script>
+      var remote = require('remote');
+      console.log(remote.require('app').getVersion());
+    </script>
+  </body>
+</html>
+```
+
+To run your app, read [Run your app](../tutorial/quick-start.md#run-your-app).
--- a/docs/api/tray-ko.md
+++ b/docs/api/tray-ko.md
@ -1,4 +1,4 @@
-# Tray
+# Tray

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

--- a/docs/api/web-frame-ko.md
+++ b/docs/api/web-frame-ko.md
@ -0,0 +1,66 @@
+# web-frame
+
+The `web-frame` module can custom the rendering of current web page.
+
+An example of zooming current page to 200%.
+
+```javascript
+var webFrame = require('web-frame');
+webFrame.setZoomFactor(2);
+```
+
+## webFrame.setZoomFactor(factor)
+
+* `factor` Number - Zoom factor
+
+Changes the zoom factor to the specified factor, zoom factor is
+zoom percent / 100, so 300% = 3.0.
+
+## webFrame.getZoomFactor()
+
+Returns the current zoom factor.
+
+## webFrame.setZoomLevel(level)
+
+* `level` Number - Zoom level
+
+Changes the zoom level to the specified level, 0 is "original size", and each
+increment above or below represents zooming 20% larger or smaller to default
+limits of 300% and 50% of original size, respectively.
+
+## webFrame.getZoomLevel()
+
+Returns the current zoom level.
+
+## webFrame.setSpellCheckProvider(language, autoCorrectWord, provider)
+
+* `language` String
+* `autoCorrectWord` Boolean
+* `provider` Object
+
+Sets a provider for spell checking in input fields and text areas.
+
+The `provider` must be an object that has a `spellCheck` method that returns
+whether the word passed is correctly spelled.
+
+An example of using [node-spellchecker][spellchecker] as provider:
+
+```javascript
+require('web-frame').setSpellCheckProvider("en-US", true, {
+  spellCheck: function(text) {
+    return !(require('spellchecker').isMisspelled(text));
+  }
+});
+```
+
+## webFrame.registerUrlSchemeAsSecure(scheme)
+
+* `scheme` String
+
+Sets the `scheme` as secure scheme.
+
+Secure schemes do not trigger mixed content warnings. For example, `https` and
+`data` are secure schemes because they cannot be corrupted by active network
+attackers.
+
+[spellchecker]: https://github.com/atom/node-spellchecker
--- a/docs/api/web-view-tag-ko.md
+++ b/docs/api/web-view-tag-ko.md
@ -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

--- a/docs/api/window-open-ko.md
+++ b/docs/api/window-open-ko.md
@ -0,0 +1,60 @@
+# `window.open` function
+
+When `window.open` is called to create a new window in web page, a new instance
+of `BrowserWindow` will be created for the `url`, and a proxy will be returned
+to `window.open` to let the page to have limited control over it.
+
+The proxy only has some limited standard functionality implemented to be
+compatible with traditional web pages, for full control of the created window
+you should create a `BrowserWindow` directly.
+
+## window.open(url, [frameName[, features]])
+
+* `url` String
+* `frameName` String
+* `features` String
+
+Creates a new window and returns an instance of `BrowserWindowProxy` class.
+
+## window.opener.postMessage(message, targetOrigin)
+
+* `message` String
+* `targetOrigin` String
+
+Sends a message to the parent window with the specified origin or `*` for no
+origin preference.
+
+## Class: BrowserWindowProxy
+
+### BrowserWindowProxy.blur()
+
+Removes focus from the child window.
+
+### BrowserWindowProxy.close()
+
+Forcefully closes the child window without calling its unload event.
+
+### BrowserWindowProxy.closed
+
+Set to true after the child window gets closed.
+
+### BrowserWindowProxy.eval(code)
+
+* `code` String
+
+Evaluates the code in the child window.
+
+### BrowserWindowProxy.focus()
+
+Focuses the child window (brings the window to front).
+
+### BrowserWindowProxy.postMessage(message, targetOrigin)
+
+* `message` String
+* `targetOrigin` String
+
+Sends a message to the child window with the specified origin or `*` for no
+origin preference.
+
+In addition to these methods, the child window implements `window.opener` object
+with no properties and a single method: