📝 Simpilify the structure of API references.

docs/api/browser-window.md

@@ -0,0 +1,461 @@
+# browser-window
+
+The `BrowserWindow` class gives you ability to create a browser window, an
+example is:
+
+```javascript
+var BrowserWindow = require('browser-window');
+
+var win = new BrowserWindow({ width: 800, height: 600, show: false });
+win.on('closed', function() {
+  win = null;
+});
+
+win.loadUrl('https://github.com');
+win.show();
+```
+
+You can also create a window without chrome by using
+[Frameless Window](frameless-window.md) API.
+
+## Class: BrowserWindow
+
+`BrowserWindow` is an
+[EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter).
+
+### new BrowserWindow(options)
+
+* `options` Object
+  * `x` Integer - Window's left offset to screen
+  * `y` Integer - Window's top offset to screen
+  * `center` Boolean - Show window in the center of the screen
+  * `min-width` Integer - Minimum width
+  * `min-height` Integer - Minimum height
+  * `max-width` Integer - Maximum width
+  * `max-height` Integer - Maximum height
+  * `resizable` Boolean - Whether window is resizable
+  * `always-on-top` Boolean - Whether the window should always stay on top of other windows
+  * `fullscreen` Boolean - Whether the window should show in fullscreen
+  * `kiosk` Boolean - The kiosk mode
+  * `title` String - Default window title
+  * `show` Boolean - Whether window should be shown when created
+  * `frame` Boolean - Specify `false` to create a
+    [Frameless Window](frameless-window.md)
+  * `node-integration` String - Can be `all`, `except-iframe`,
+    `manual-enable-iframe` or `disable`.
+  * `accept-first-mouse` Boolean - Whether the web view accepts a single
+     mouse-down event that simultaneously activates the window
+
+Creates a new `BrowserWindow` with native properties set by the `options`.
+Usually you only need to set the `width` and `height`, other properties will
+have decent default values.
+
+By default the `node-integration` option is `except-iframe`, which means node
+integration is disabled in all iframes, . You can also set it to `all`, with
+which node integration is available to the main page and all its iframes, or
+`manual-enable-iframe`, which is like `except-iframe`, but would enable iframes
+whose name is suffixed by `-enable-node-integration`. And setting to `disable`
+would disable the node integration in both the main page and its iframes.
+
+An example of enable node integration in iframe with `node-integration` set to
+`manual-enable-iframe`:
+
+```html
+<!-- iframe with node integration enabled -->
+<iframe name="gh-enable-node-integration" src="https://github.com"></iframe>
+
+<!-- iframe with node integration disabled -->
+<iframe src="http://jandan.net"></iframe>
+```
+
+And in atom-shell, the security limitaion of iframe is stricter than normal
+browser, by default iframe is sandboxed with all permissions except the
+`allow-same-origin`, which means iframe could not access parent's js context.
+
+If you want to enable things like `parent.window.process.exit()` in iframe,
+you should explictly set `sandbox` to `none`:
+
+```html
+<iframe sandbox="none" src="https://github.com"></iframe>
+```
+
+### Event: 'page-title-updated'
+
+* `event` Event
+
+Emitted when the document changed its title, calling `event.preventDefault()`
+would prevent the native window's title to change.
+
+### Event: 'close'
+
+* `event` Event
+
+Emitted when the window is going to be closed. It's emitted before the
+`beforeunload` and `unload` event of DOM, calling `event.preventDefault()`
+would cancel the close.
+
+Usually you would want to use the `beforeunload` handler to decide whether the
+window should be closed, which will also be called when the window is
+reloaded. In atom-shell, returning an empty string or `false` would cancel the
+close. An example is:
+
+```javascript
+window.onbeforeunload = function(e) {
+  console.log('I do not want to be closed');
+
+  // Unlike usual browsers, in which a string should be returned and the user is
+  // prompted to confirm the page unload. atom-shell gives the power completely
+  // to the developers, return empty string or false would prevent the unloading
+  // now. You can also use the dialog API to let user confirm it.
+  return false;
+};
+```
+
+### Event: 'closed'
+
+Emitted when the window is closed. After you have received this event you should
+remove the reference to the window and avoid using it anymore.
+
+### Event: 'unresponsive'
+
+Emiited when the web page becomes unresponsive.
+
+### Event: 'responsive'
+
+Emitted when the unresponsive web page becomes responsive again.
+
+### Event: 'blur'
+
+Emiited when window loses focus.
+
+### Class Method: BrowserWindow.getAllWindows()
+
+Returns an array of all opened browser windows.
+
+### Class Method: BrowserWindow.getFocusedWindow()
+
+Returns the window that is focused in this application.
+
+### Class Method: BrowserWindow.fromWebContents(webContents)
+
+* `webContents` WebContents
+
+Find a window according to the `webContents` it owns
+
+### BrowserWindow.webContents
+
+The `WebContents` object this window owns, all web page related events and
+operations would be done via it.
+
+### BrowserWindow.devToolsWebContents
+
+Get the `WebContents` of devtools of this window.
+
+### BrowserWindow.destroy()
+
+Force closing the window, the `unload` and `beforeunload` event won't be emitted
+for the web page, and `close` event would also not be emitted for this window,
+but it would gurrantee the `closed` event to be emitted.
+
+You should only use this method when the web page has crashed.
+
+### BrowserWindow.close()
+
+Try to close the window, this has the same effect with user manually clicking
+the close button of the window. The web page may cancel the close though, see
+the [close event](window#event-close).
+
+### BrowserWindow.focus()
+
+Focus on the window.
+
+### BrowserWindow.isFocused()
+
+Returns whether the window is focused.
+
+### BrowserWindow.show()
+
+Shows the window.
+
+### BrowserWindow.hide()
+
+Hides the window.
+
+### BrowserWindow.isVisible()
+
+Returns whether the window is visible to the user.
+
+### BrowserWindow.maximize()
+
+Maximizes the window.
+
+### BrowserWindow.unmaximize()
+
+Unmaximizes the window.
+
+### BrowserWindow.minimize()
+
+Minimizes the window. On some platforms the minimized window will be shown in
+the Dock.
+
+### BrowserWindow.restore()
+
+Restores the window from minimized state to its previous state.
+
+### BrowserWindow.setFullScreen(flag)
+
+* `flag` Boolean
+
+Sets whether the window should be in fullscreen mode.
+
+### BrowserWindow.isFullScreen()
+
+Returns whether the window is in fullscreen mode.
+
+### BrowserWindow.setSize(width, height)
+
+* `width` Integer
+* `height` Integer
+
+Resizes the window to `width` and `height`.
+
+### BrowserWindow.getSize()
+
+Returns an array that contains window's width and height.
+
+### BrowserWindow.setMinimumSize(width, height)
+
+* `width` Integer
+* `height` Integer
+
+Sets the minimum size of window to `width` and `height`.
+
+### BrowserWindow.getMinimumSize()
+
+Returns an array that contains window's minimum width and height.
+
+### BrowserWindow.setMaximumSize(width, height)
+
+* `width` Integer
+* `height` Integer
+
+Sets the maximum size of window to `width` and `height`.
+
+### BrowserWindow.getMaximumSize()
+
+Returns an array that contains window's maximum width and height.
+
+### BrowserWindow.setResizable(resizable)
+
+* `resizable` Boolean
+
+Sets whether the window can be manually resized by user.
+
+### BrowserWindow.isResizable()
+
+Returns whether the window can be manually resized by user.
+
+### BrowserWindow.setAlwaysOnTop(flag)
+
+* `flag` Boolean
+
+Sets whether the window should show always on top of other windows. After
+setting this, the window is still a normal window, not a toolbox window which
+can not be focused on.
+
+### BrowserWindow.isAlwaysOnTop()
+
+Returns whether the window is always on top of other windows.
+
+### BrowserWindow.center()
+
+Moves window to the center of the screen.
+
+### BrowserWindow.setPosition(x, y)
+
+* `x` Integer
+* `y` Integer
+
+Moves window to `x` and `y`.
+
+### BrowserWindow.getPosition()
+
+Returns an array that contains window's current position.
+
+### BrowserWindow.setTitle(title)
+
+* `title` String
+
+Changes the title of native window to `title`.
+
+### BrowserWindow.getTitle()
+
+Returns the title of the native window.
+
+**Note:** The title of web page can be different from the title of the native
+**window.
+
+### BrowserWindow.flashFlame()
+
+Flashes the window to attract user's attention.
+
+### BrowserWindow.setKiosk(flag)
+
+* `flag` Boolean
+
+Enters or leaves the kiosk mode.
+
+### BrowserWindow.isKiosk()
+
+Returns whether the window is in kiosk mode.
+
+### BrowserWindow.openDevTools()
+
+Opens the developer tools.
+
+### BrowserWindow.closeDevTools()
+
+Closes the developer tools.
+
+### BrowserWindow.inspectElement(x, y)
+
+* `x` Integer
+* `y` Integer
+
+Starts inspecting element at position (`x`, `y`).
+
+### BrowserWindow.focusOnWebView()
+
+### BrowserWindow.blurWebView()
+
+### BrowserWindow.capturePage([rect, ]callback)
+
+* `rect` Object - The area of page to be captured
+  * `x`
+  * `y`
+  * `width`
+  * `height`
+* `callback` Function
+
+Captures the snapshot of page within `rect`, upon completion `callback` would be
+called with `callback(image)`, the `image` is a `Buffer` that stores the PNG
+encoded data of the snapshot. Omitting the `rect` would capture the whole
+visible page.
+
+You can write received `image` directly to a `.png` file, or you can base64
+encode it and use data URL to embed the image in HTML.
+
+**Note:** Be sure to read documents on remote buffer in
+[remote](remote.md) if you are going to use this API in renderer
+process.
+
+### BrowserWindow.loadUrl(url)
+
+Same with `webContents.loadUrl(url)`.
+
+## Class: WebContents
+
+A `WebContents` is responsible for rendering and controlling a web page.
+
+`WebContents` is an
+[EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter).
+
+### Event: 'crashed'
+
+Emitted when the renderer process is crashed.
+
+### Event: 'did-finish-load'
+
+Emitted when the navigation is done, i.e. the spinner of the tab will stop
+spinning, and the onload event was dispatched.
+
+### Event: 'did-start-loading'
+
+### Event: 'did-stop-loading'
+
+### WebContents.loadUrl(url)
+
+* `url` URL
+
+Loads the `url` in the window, the `url` must contains the protocol prefix,
+e.g. the `http://` or `file://`.
+
+### WebContents.getUrl()
+
+Returns URL of current web page.
+
+### WebContents.getTitle()
+
+Returns the title of web page.
+
+### WebContents.isLoading()
+
+Returns whether web page is still loading resources.
+
+### WebContents.isWaitingForResponse()
+
+Returns whether web page is waiting for a first-response for the main resource
+of the page.
+
+### WebContents.stop()
+
+Stops any pending navigation.
+
+### WebContents.reload()
+
+Reloads current page.
+
+### WebContents.reloadIgnoringCache()
+
+Reloads current page and ignores cache.
+
+### WebContents.canGoBack()
+
+Returns whether the web page can go back.
+
+### WebContents.canGoForward()
+
+Returns whether the web page can go forward.
+
+### WebContents.canGoToOffset(offset)
+
+* `offset` Integer
+
+Returns whether the web page can go to `offset`.
+
+### WebContents.goBack()
+
+Makes the web page go back.
+
+### WebContents.goForward()
+
+Makes the web page go forward.
+
+### WebContents.goToIndex(index)
+
+* `index` Integer
+
+Navigates to the specified absolute index.
+
+### WebContents.goToOffset(offset)
+
+* `offset` Integer
+
+Navigates to the specified offset from the "current entry".
+
+### WebContents.IsCrashed()
+
+Whether the renderer process has crashed.
+
+### WebContents.executeJavaScript(code)
+
+* `code` String
+
+Evaluate `code` in page.
+
+### WebContents.send(channel[, args...])
+
+* `channel` String
+
+Send `args..` to the web page via `channel` in asynchronous message, the web
+page can handle it by listening to the `channel` event of `ipc` module.