8 |
9 | bool TtsPlatformImpl::LoadBuiltInTtsExtension(
10 | content::BrowserContext* browser_context) {
11 | return false;
12 | }
13 |
14 | std::string TtsPlatformImpl::error() {
15 | return error_;
16 | }
17 |
18 | void TtsPlatformImpl::clear_error() {
19 | error_ = std::string();
20 | }
21 |
22 | void TtsPlatformImpl::set_error(const std::string& error) {
23 | error_ = error;
24 | }
25 |
26 | void TtsPlatformImpl::WillSpeakUtteranceWithVoice(const Utterance* utterance,
27 | const VoiceData& voice_data) {
28 | }
--------------------------------------------------------------------------------
/chromium_src/chrome/browser/browser_process.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "chrome/browser/browser_process.h"
6 |
7 | #include "chrome/browser/printing/print_job_manager.h"
8 | #include "ui/base/l10n/l10n_util.h"
9 |
10 | BrowserProcess* g_browser_process = NULL;
11 |
12 | BrowserProcess::BrowserProcess() {
13 | g_browser_process = this;
14 |
15 | print_job_manager_.reset(new printing::PrintJobManager);
16 | }
17 |
18 | BrowserProcess::~BrowserProcess() {
19 | g_browser_process = NULL;
20 | }
21 |
22 | std::string BrowserProcess::GetApplicationLocale() {
23 | return l10n_util::GetApplicationLocale("");
24 | }
25 |
26 | printing::PrintJobManager* BrowserProcess::print_job_manager() {
27 | return print_job_manager_.get();
28 | }
29 |
--------------------------------------------------------------------------------
/docs/api/file-object.md:
--------------------------------------------------------------------------------
1 | # `File` object
2 |
3 | The DOM's File interface provides abstraction around native files, in order to
4 | let users work on native files directly with HTML5 file API, atom-shell has
5 | added a `path` attribute to `File` interface which exposes the file's real path
6 | on filesystem.
7 |
8 | Example on getting real path of a dragged file:
9 |
10 | ```html
11 |
12 | Drag your file here
13 |
14 |
15 |
30 | ```
31 |
--------------------------------------------------------------------------------
/atom/browser/auto_updater.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_AUTO_UPDATER_H_
6 | #define ATOM_BROWSER_AUTO_UPDATER_H_
7 |
8 | #include
9 |
10 | #include "base/basictypes.h"
11 |
12 | namespace auto_updater {
13 |
14 | class AutoUpdaterDelegate;
15 |
16 | class AutoUpdater {
17 | public:
18 | // Gets/Sets the delegate.
19 | static AutoUpdaterDelegate* GetDelegate();
20 | static void SetDelegate(AutoUpdaterDelegate* delegate);
21 |
22 | static void SetFeedURL(const std::string& url);
23 | static void CheckForUpdates();
24 |
25 | private:
26 | static AutoUpdaterDelegate* delegate_;
27 |
28 | DISALLOW_IMPLICIT_CONSTRUCTORS(AutoUpdater);
29 | };
30 |
31 | } // namespace auto_updater
32 |
33 | #endif // ATOM_BROWSER_AUTO_UPDATER_H_
34 |
--------------------------------------------------------------------------------
/chromium_src/chrome/browser/printing/printing_ui_web_contents_observer.cc:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "chrome/browser/printing/printing_ui_web_contents_observer.h"
6 |
7 | #include "content/public/browser/browser_thread.h"
8 | #include "content/public/browser/web_contents.h"
9 |
10 | PrintingUIWebContentsObserver::PrintingUIWebContentsObserver(
11 | content::WebContents* web_contents)
12 | : content::WebContentsObserver(web_contents) {
13 | DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
14 | }
15 |
16 | gfx::NativeView PrintingUIWebContentsObserver::GetParentView() {
17 | DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
18 | return web_contents() ? web_contents()->GetNativeView() : NULL;
19 | }
20 |
--------------------------------------------------------------------------------
/chromium_src/chrome/browser/printing/print_view_manager_observer.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef CHROME_BROWSER_PRINTING_PRINT_VIEW_MANAGER_OBSERVER_H_
6 | #define CHROME_BROWSER_PRINTING_PRINT_VIEW_MANAGER_OBSERVER_H_
7 |
8 | namespace printing {
9 |
10 | // An interface the PrintViewManager uses to notify an observer when the print
11 | // dialog is shown. Register the observer via PrintViewManager::set_observer.
12 | class PrintViewManagerObserver {
13 | public:
14 | // Notifies the observer that the print dialog was shown.
15 | virtual void OnPrintDialogShown() = 0;
16 |
17 | protected:
18 | virtual ~PrintViewManagerObserver() {}
19 | };
20 |
21 | } // namespace printing
22 |
23 | #endif // CHROME_BROWSER_PRINTING_PRINT_VIEW_MANAGER_OBSERVER_H_
24 |
--------------------------------------------------------------------------------
/atom/browser/api/lib/auto-updater.coffee:
--------------------------------------------------------------------------------
1 | autoUpdater = process.atomBinding('auto_updater').autoUpdater
2 | EventEmitter = require('events').EventEmitter
3 |
4 | autoUpdater.__proto__ = EventEmitter.prototype
5 |
6 | autoUpdater.on 'update-downloaded-raw', (args...) ->
7 | args[3] = new Date(args[3]) # releaseDate
8 | @emit 'update-downloaded', args..., => @quitAndInstall()
9 |
10 | autoUpdater.quitAndInstall = ->
11 | # If we don't have any window then quitAndInstall immediately.
12 | BrowserWindow = require 'browser-window'
13 | windows = BrowserWindow.getAllWindows()
14 | if windows.length is 0
15 | @_quitAndInstall()
16 | return
17 |
18 | # Do the restart after all windows have been closed.
19 | app = require 'app'
20 | app.removeAllListeners 'window-all-closed'
21 | app.once 'window-all-closed', @_quitAndInstall.bind(this)
22 | win.close() for win in windows
23 |
24 | module.exports = autoUpdater
25 |
--------------------------------------------------------------------------------
/docs/api/shell.md:
--------------------------------------------------------------------------------
1 | # shell
2 |
3 | The `shell` module provides functions related to desktop integration.
4 |
5 | An example of opening a URL in default browser:
6 |
7 | ```javascript
8 | var shell = require('shell');
9 | shell.openExternal('https://github.com');
10 | ```
11 |
12 | ## shell.showItemInFolder(fullPath)
13 |
14 | * `fullPath` String
15 |
16 | Show the given file in a file manager. If possible, select the file.
17 |
18 | ## shell.openItem(fullPath)
19 |
20 | * `fullPath` String
21 |
22 | Open the given file in the desktop's default manner.
23 |
24 | ## shell.openExternal(url)
25 |
26 | * `url` String
27 |
28 | Open the given external protocol URL in the desktop's default manner. (For
29 | example, mailto: URLs in the default mail user agent.)
30 |
31 | ## shell.moveItemToTrash(fullPath)
32 |
33 | * `fullPath` String
34 |
35 | Move the given file to trash.
36 |
37 | ## shell.beep()
38 |
39 | Play the beep sound.
40 |
--------------------------------------------------------------------------------
/docs/api/web-frame.md:
--------------------------------------------------------------------------------
1 | # web-frame
2 |
3 | The `web-frame` module can custom the rendering of current web page.
4 |
5 | An example of zooming current page to 200%.
6 |
7 | ```javascript
8 | var webFrame = require('web-frame');
9 | webFrame.setZoomFactor(2);
10 | ```
11 |
12 | ## webFrame.setZoomFactor(factor)
13 |
14 | * `factor` Number - Zoom factor
15 |
16 | Changes the zoom factor to the specified factor, zoom factor is
17 | zoom percent / 100, so 300% = 3.0.
18 |
19 | ## webFrame.getZoomFactor()
20 |
21 | Returns the current zoom factor.
22 |
23 | ## webFrame.setZoomLevel(level)
24 |
25 | * `level` Number - Zoom level
26 |
27 | Changes the zoom level to the specified level, 0 is "original size", and each
28 | increment above or below represents zooming 20% larger or smaller to default
29 | limits of 300% and 50% of original size, respectively.
30 |
31 | ## webFrame.getZoomLevel()
32 |
33 | Returns the current zoom level.
34 |
--------------------------------------------------------------------------------
/atom/browser/ui/tray_icon_win.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_UI_TRAY_ICON_WIN_H_
6 | #define ATOM_BROWSER_UI_TRAY_ICON_WIN_H_
7 |
8 | #include
9 |
10 | #include "atom/browser/ui/tray_icon.h"
11 |
12 | namespace atom {
13 |
14 | class TrayIconWin : public TrayIcon {
15 | public:
16 | TrayIconWin();
17 | virtual ~TrayIconWin();
18 |
19 | virtual void SetImage(const gfx::ImageSkia& image) OVERRIDE;
20 | virtual void SetPressedImage(const gfx::ImageSkia& image) OVERRIDE;
21 | virtual void SetToolTip(const std::string& tool_tip) OVERRIDE;
22 | virtual void SetContextMenu(ui::SimpleMenuModel* menu_model) OVERRIDE;
23 |
24 | private:
25 | DISALLOW_COPY_AND_ASSIGN(TrayIconWin);
26 | };
27 |
28 | } // namespace atom
29 |
30 | #endif // ATOM_BROWSER_UI_TRAY_ICON_WIN_H_
31 |
--------------------------------------------------------------------------------
/spec/api-app-spec.coffee:
--------------------------------------------------------------------------------
1 | assert = require 'assert'
2 | app = require('remote').require 'app'
3 |
4 | describe 'app module', ->
5 | describe 'app.getVersion()', ->
6 | it 'returns the version field of package.json', ->
7 | assert.equal app.getVersion(), '0.1.0'
8 |
9 | describe 'app.setVersion(version)', ->
10 | it 'overrides the version', ->
11 | assert.equal app.getVersion(), '0.1.0'
12 | app.setVersion 'test-version'
13 | assert.equal app.getVersion(), 'test-version'
14 | app.setVersion '0.1.0'
15 |
16 | describe 'app.getName()', ->
17 | it 'returns the name field of package.json', ->
18 | assert.equal app.getName(), 'Atom Shell Test App'
19 |
20 | describe 'app.setName(name)', ->
21 | it 'overrides the name', ->
22 | assert.equal app.getName(), 'Atom Shell Test App'
23 | app.setName 'test-name'
24 | assert.equal app.getName(), 'test-name'
25 | app.setName 'Atom Shell Test App'
26 |
--------------------------------------------------------------------------------
/atom/app/atom_content_client.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_APP_ATOM_CONTENT_CLIENT_H_
6 | #define ATOM_APP_ATOM_CONTENT_CLIENT_H_
7 |
8 | #include
9 | #include
10 |
11 | #include "brightray/common/content_client.h"
12 |
13 | namespace atom {
14 |
15 | class AtomContentClient : public brightray::ContentClient {
16 | public:
17 | AtomContentClient();
18 | virtual ~AtomContentClient();
19 |
20 | protected:
21 | // content::ContentClient:
22 | virtual std::string GetProduct() const OVERRIDE;
23 | virtual void AddAdditionalSchemes(
24 | std::vector* standard_schemes,
25 | std::vector* savable_schemes) OVERRIDE;
26 |
27 | private:
28 | DISALLOW_COPY_AND_ASSIGN(AtomContentClient);
29 | };
30 |
31 | } // namespace atom
32 |
33 | #endif // ATOM_APP_ATOM_CONTENT_CLIENT_H_
34 |
--------------------------------------------------------------------------------
/atom/common/api/object_life_monitor.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_API_OBJECT_LIFE_MONITOR_H_
6 | #define ATOM_COMMON_API_OBJECT_LIFE_MONITOR_H_
7 |
8 | #include "base/basictypes.h"
9 | #include "native_mate/scoped_persistent.h"
10 |
11 | namespace atom {
12 |
13 | class ObjectLifeMonitor {
14 | public:
15 | static void BindTo(v8::Isolate* isolate,
16 | v8::Handle target,
17 | v8::Handle destructor);
18 |
19 | private:
20 | ObjectLifeMonitor();
21 |
22 | static void WeakCallback(
23 | const v8::WeakCallbackData& data);
24 |
25 | mate::ScopedPersistent handle_;
26 |
27 | DISALLOW_COPY_AND_ASSIGN(ObjectLifeMonitor);
28 | };
29 |
30 | } // namespace atom
31 |
32 | #endif // ATOM_COMMON_API_OBJECT_LIFE_MONITOR_H_
33 |
--------------------------------------------------------------------------------
/atom/common/node_bindings_mac.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NODE_BINDINGS_MAC_H_
6 | #define ATOM_COMMON_NODE_BINDINGS_MAC_H_
7 |
8 | #include "atom/common/node_bindings.h"
9 | #include "base/compiler_specific.h"
10 |
11 | namespace atom {
12 |
13 | class NodeBindingsMac : public NodeBindings {
14 | public:
15 | explicit NodeBindingsMac(bool is_browser);
16 | virtual ~NodeBindingsMac();
17 |
18 | virtual void RunMessageLoop() OVERRIDE;
19 |
20 | private:
21 | // Called when uv's watcher queue changes.
22 | static void OnWatcherQueueChanged(uv_loop_t* loop);
23 |
24 | virtual void PollEvents() OVERRIDE;
25 |
26 | // Kqueue to poll for uv's backend fd.
27 | int kqueue_;
28 |
29 | DISALLOW_COPY_AND_ASSIGN(NodeBindingsMac);
30 | };
31 |
32 | } // namespace atom
33 |
34 | #endif // ATOM_COMMON_NODE_BINDINGS_MAC_H_
35 |
--------------------------------------------------------------------------------
/atom/browser/api/atom_api_menu_mac.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
6 | #define ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
7 |
8 | #include "atom/browser/api/atom_api_menu.h"
9 |
10 | #include
11 |
12 | #import "atom/browser/ui/cocoa/atom_menu_controller.h"
13 |
14 | namespace atom {
15 |
16 | namespace api {
17 |
18 | class MenuMac : public Menu {
19 | protected:
20 | MenuMac();
21 |
22 | virtual void Popup(Window* window) OVERRIDE;
23 |
24 | base::scoped_nsobject menu_controller_;
25 |
26 | private:
27 | friend class Menu;
28 |
29 | static void SendActionToFirstResponder(const std::string& action);
30 |
31 | DISALLOW_COPY_AND_ASSIGN(MenuMac);
32 | };
33 |
34 | } // namespace api
35 |
36 | } // namespace atom
37 |
38 | #endif // ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
39 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Atom Shell [](https://travis-ci.org/atom/atom-shell)
2 |
3 | The Atom Shell framework lets you write cross-platform desktop applications
4 | using JavaScript, HTML and CSS. It is based on [node.js](http://nodejs.org) and
5 | [Chromium](http://www.chromium.org) and is used in the [Atom
6 | editor](https://github.com/atom/atom).
7 |
8 | ## Downloads
9 |
10 | Prebuilt binaries of atom-shell for Linux, Windows and Mac can be found on the
11 | [releases](https://github.com/atom/atom-shell/releases) page.
12 |
13 | ## Documentation
14 |
15 | Guides and the API reference are located in the
16 | [docs](https://github.com/atom/atom-shell/tree/master/docs) directory. It also
17 | contains documents describing how to build and contribute to atom-shell.
18 |
19 | ## Community
20 |
21 | There is an [`atom-shell` category on the Atom forums](http://discuss.atom.io/category/atom-shell)
22 | as well as an `#atom-shell` channel on Freenode.
23 |
--------------------------------------------------------------------------------
/atom/common/node_bindings_linux.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NODE_BINDINGS_LINUX_H_
6 | #define ATOM_COMMON_NODE_BINDINGS_LINUX_H_
7 |
8 | #include "base/compiler_specific.h"
9 | #include "atom/common/node_bindings.h"
10 |
11 | namespace atom {
12 |
13 | class NodeBindingsLinux : public NodeBindings {
14 | public:
15 | explicit NodeBindingsLinux(bool is_browser);
16 | virtual ~NodeBindingsLinux();
17 |
18 | virtual void RunMessageLoop() OVERRIDE;
19 |
20 | private:
21 | // Called when uv's watcher queue changes.
22 | static void OnWatcherQueueChanged(uv_loop_t* loop);
23 |
24 | virtual void PollEvents() OVERRIDE;
25 |
26 | // Epoll to poll for uv's backend fd.
27 | int epoll_;
28 |
29 | DISALLOW_COPY_AND_ASSIGN(NodeBindingsLinux);
30 | };
31 |
32 | } // namespace atom
33 |
34 | #endif // ATOM_COMMON_NODE_BINDINGS_LINUX_H_
35 |
--------------------------------------------------------------------------------
/atom/browser/browser_linux.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "atom/browser/browser.h"
6 |
7 | #include
8 |
9 | #include "atom/browser/native_window.h"
10 | #include "atom/browser/window_list.h"
11 | #include "atom/common/atom_version.h"
12 |
13 | namespace atom {
14 |
15 | void Browser::Focus() {
16 | // Focus on the first visible window.
17 | WindowList* list = WindowList::GetInstance();
18 | for (WindowList::iterator iter = list->begin(); iter != list->end(); ++iter) {
19 | NativeWindow* window = *iter;
20 | if (window->IsVisible()) {
21 | window->Focus(true);
22 | break;
23 | }
24 | }
25 | }
26 |
27 | std::string Browser::GetExecutableFileVersion() const {
28 | return ATOM_VERSION_STRING;
29 | }
30 |
31 | std::string Browser::GetExecutableFileProductName() const {
32 | return "Atom-Shell";
33 | }
34 |
35 | } // namespace atom
36 |
--------------------------------------------------------------------------------
/docs/api/ipc-renderer.md:
--------------------------------------------------------------------------------
1 | # ipc (renderer)
2 |
3 | The `ipc` module provides a few methods so you can send synchronous and
4 | asynchronous messages to the browser, and also receive messages sent from
5 | browser. If you want to make use of modules of browser from renderer, you
6 | might consider using the [remote](remote.md) module.
7 |
8 | See [ipc (browser)](ipc-browser.md) for examples.
9 |
10 | ## ipc.send(channel[, args...])
11 |
12 | Send `args..` to the web page via `channel` in asynchronous message, the browser
13 | process can handle it by listening to the `channel` event of `ipc` module.
14 |
15 | ## ipc.sendSync(channel[, args...])
16 |
17 | Send `args..` to the web page via `channel` in synchronous message, and returns
18 | the result sent from browser. The browser process can handle it by listening to
19 | the `channel` event of `ipc` module, and returns by setting `event.returnValue`.
20 |
21 | **Note:** Usually developers should never use this API, since sending
22 | synchronous message would block the whole web page.
23 |
--------------------------------------------------------------------------------
/atom/browser/atom_access_token_store.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
6 | #define ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
7 |
8 | #include "content/public/browser/access_token_store.h"
9 |
10 | namespace atom {
11 |
12 | class AtomBrowserContext;
13 |
14 | class AtomAccessTokenStore : public content::AccessTokenStore {
15 | public:
16 | AtomAccessTokenStore();
17 | virtual ~AtomAccessTokenStore();
18 |
19 | // content::AccessTokenStore:
20 | virtual void LoadAccessTokens(
21 | const LoadAccessTokensCallbackType& callback) OVERRIDE;
22 | virtual void SaveAccessToken(const GURL& server_url,
23 | const base::string16& access_token) OVERRIDE;
24 |
25 | private:
26 | DISALLOW_COPY_AND_ASSIGN(AtomAccessTokenStore);
27 | };
28 |
29 | } // namespace atom
30 |
31 | #endif // ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
32 |
--------------------------------------------------------------------------------
/atom/browser/ui/views/menu_layout.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_UI_VIEWS_MENU_LAYOUT_H_
6 | #define ATOM_BROWSER_UI_VIEWS_MENU_LAYOUT_H_
7 |
8 | #include "ui/views/layout/fill_layout.h"
9 |
10 | namespace atom {
11 |
12 | class MenuLayout : public views::FillLayout {
13 | public:
14 | explicit MenuLayout(int menu_height);
15 | virtual ~MenuLayout();
16 |
17 | // views::LayoutManager:
18 | virtual void Layout(views::View* host) OVERRIDE;
19 | virtual gfx::Size GetPreferredSize(const views::View* host) const OVERRIDE;
20 | virtual int GetPreferredHeightForWidth(
21 | const views::View* host, int width) const OVERRIDE;
22 |
23 | private:
24 | bool HasMenu(const views::View* host) const;
25 |
26 | int menu_height_;
27 |
28 | DISALLOW_COPY_AND_ASSIGN(MenuLayout);
29 | };
30 |
31 | } // namespace atom
32 |
33 | #endif // ATOM_BROWSER_UI_VIEWS_MENU_LAYOUT_H_
34 |
--------------------------------------------------------------------------------
/atom/common/api/atom_api_screen.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "atom/common/native_mate_converters/gfx_converter.h"
6 | #include "atom/common/node_includes.h"
7 |
8 | namespace {
9 |
10 | void Initialize(v8::Handle exports, v8::Handle unused,
11 | v8::Handle context, void* priv) {
12 | gfx::Screen* screen = gfx::Screen::GetNativeScreen();
13 | mate::Dictionary dict(context->GetIsolate(), exports);
14 | dict.SetMethod("getCursorScreenPoint",
15 | base::Bind(&gfx::Screen::GetCursorScreenPoint,
16 | base::Unretained(screen)));
17 | dict.SetMethod("getPrimaryDisplay",
18 | base::Bind(&gfx::Screen::GetPrimaryDisplay,
19 | base::Unretained(screen)));
20 | }
21 |
22 | } // namespace
23 |
24 | NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_screen, Initialize)
25 |
--------------------------------------------------------------------------------
/atom/common/native_mate_converters/value_converter.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_VALUE_CONVERTER_H_
6 | #define ATOM_COMMON_NATIVE_MATE_CONVERTERS_VALUE_CONVERTER_H_
7 |
8 | #include "native_mate/converter.h"
9 |
10 | namespace base {
11 | class DictionaryValue;
12 | class ListValue;
13 | }
14 |
15 | namespace mate {
16 |
17 | template<>
18 | struct Converter {
19 | static bool FromV8(v8::Isolate* isolate,
20 | v8::Handle val,
21 | base::DictionaryValue* out);
22 | };
23 |
24 | template<>
25 | struct Converter {
26 | static bool FromV8(v8::Isolate* isolate,
27 | v8::Handle val,
28 | base::ListValue* out);
29 | };
30 |
31 | } // namespace mate
32 |
33 | #endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_VALUE_CONVERTER_H_
34 |
--------------------------------------------------------------------------------
/atom/browser/window_list_observer.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_WINDOW_LIST_OBSERVER_H_
6 | #define ATOM_BROWSER_WINDOW_LIST_OBSERVER_H_
7 |
8 | namespace atom {
9 |
10 | class NativeWindow;
11 |
12 | class WindowListObserver {
13 | public:
14 | // Called immediately after a window is added to the list.
15 | virtual void OnWindowAdded(NativeWindow* window) {}
16 |
17 | // Called immediately after a window is removed from the list.
18 | virtual void OnWindowRemoved(NativeWindow* window) {}
19 |
20 | // Called when a window close is cancelled by beforeunload handler.
21 | virtual void OnWindowCloseCancelled(NativeWindow* window) {}
22 |
23 | // Called immediately after all windows are closed.
24 | virtual void OnWindowAllClosed() {}
25 |
26 | protected:
27 | virtual ~WindowListObserver() {}
28 | };
29 |
30 | } // namespace atom
31 |
32 | #endif // ATOM_BROWSER_WINDOW_LIST_OBSERVER_H_
33 |
--------------------------------------------------------------------------------
/atom/browser/resources/mac/Info.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | CFBundleDisplayName
6 | ${PRODUCT_NAME}
7 | CFBundleExecutable
8 | ${PRODUCT_NAME}
9 | CFBundleIdentifier
10 | com.github.atom
11 | CFBundleInfoDictionaryVersion
12 | 6.0
13 | CFBundleName
14 | ${PRODUCT_NAME}
15 | CFBundlePackageType
16 | APPL
17 | CFBundleIconFile
18 | atom.icns
19 | CFBundleVersion
20 | 0.18.2
21 | LSMinimumSystemVersion
22 | 10.8.0
23 | NSMainNibFile
24 | MainMenu
25 | NSPrincipalClass
26 | AtomApplication
27 | NSSupportsAutomaticGraphicsSwitching
28 |
29 |
30 |
31 |
--------------------------------------------------------------------------------
/atom/common/node_includes.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NODE_INCLUDES_H_
6 | #define ATOM_COMMON_NODE_INCLUDES_H_
7 |
8 | // Include common headers for using node APIs.
9 |
10 | #undef CHECK
11 | #undef CHECK_EQ
12 | #undef CHECK_NE
13 | #undef CHECK_GE
14 | #undef CHECK_GT
15 | #undef CHECK_LE
16 | #undef CHECK_LT
17 | #undef DISALLOW_COPY_AND_ASSIGN
18 | #undef debug_string // This is defined in OS X 10.9 SDK in AssertMacros.h.
19 | #include "vendor/node/src/env.h"
20 | #include "vendor/node/src/env-inl.h"
21 | #include "vendor/node/src/node.h"
22 | #include "vendor/node/src/node_buffer.h"
23 | #include "vendor/node/src/node_internals.h"
24 |
25 | namespace atom {
26 | // Defined in node_bindings.cc.
27 | // For renderer it's created in atom_renderer_client.cc.
28 | // For browser it's created in atom_browser_main_parts.cc.
29 | extern node::Environment* global_env;
30 | }
31 |
32 | #endif // ATOM_COMMON_NODE_INCLUDES_H_
33 |
--------------------------------------------------------------------------------
/chromium_src/chrome/common/tts_utterance_request.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef CHROME_COMMON_TTS_UTTERANCE_REQUEST_H_
6 | #define CHROME_COMMON_TTS_UTTERANCE_REQUEST_H_
7 |
8 | #include
9 |
10 | #include "base/basictypes.h"
11 | #include "base/strings/string16.h"
12 |
13 | struct TtsUtteranceRequest {
14 | TtsUtteranceRequest();
15 | ~TtsUtteranceRequest();
16 |
17 | int id;
18 | std::string text;
19 | std::string lang;
20 | std::string voice;
21 | float volume;
22 | float rate;
23 | float pitch;
24 | };
25 |
26 | struct TtsVoice {
27 | TtsVoice();
28 | ~TtsVoice();
29 |
30 | std::string voice_uri;
31 | std::string name;
32 | std::string lang;
33 | bool local_service;
34 | bool is_default;
35 | };
36 |
37 | struct TtsUtteranceResponse {
38 | TtsUtteranceResponse();
39 | ~TtsUtteranceResponse();
40 |
41 | int id;
42 | };
43 |
44 | #endif // CHROME_COMMON_TTS_UTTERANCE_REQUEST_H_
--------------------------------------------------------------------------------
/chromium_src/chrome/browser/printing/printing_ui_web_contents_observer.h:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef CHROME_BROWSER_PRINTING_PRINTING_UI_WEB_CONTENTS_OBSERVER_H_
6 | #define CHROME_BROWSER_PRINTING_PRINTING_UI_WEB_CONTENTS_OBSERVER_H_
7 |
8 | #include "base/basictypes.h"
9 | #include "content/public/browser/web_contents_observer.h"
10 | #include "ui/gfx/native_widget_types.h"
11 |
12 | // Wrapper used to keep track of the lifetime of a WebContents.
13 | // Lives on the UI thread.
14 | class PrintingUIWebContentsObserver : public content::WebContentsObserver {
15 | public:
16 | explicit PrintingUIWebContentsObserver(content::WebContents* web_contents);
17 |
18 | // Return the parent NativeView of the observed WebContents.
19 | gfx::NativeView GetParentView();
20 |
21 | private:
22 | DISALLOW_COPY_AND_ASSIGN(PrintingUIWebContentsObserver);
23 | };
24 |
25 | #endif // CHROME_BROWSER_PRINTING_PRINTING_UI_WEB_CONTENTS_OBSERVER_H_
26 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2014 GitHub Inc.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining
4 | a copy of this software and associated documentation files (the
5 | "Software"), to deal in the Software without restriction, including
6 | without limitation the rights to use, copy, modify, merge, publish,
7 | distribute, sublicense, and/or sell copies of the Software, and to
8 | permit persons to whom the Software is furnished to do so, subject to
9 | the following conditions:
10 |
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 |
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/atom/browser/javascript_environment.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
6 | #define ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
7 |
8 | #include "base/basictypes.h"
9 | #include "gin/public/isolate_holder.h"
10 |
11 | namespace atom {
12 |
13 | class JavascriptEnvironment {
14 | public:
15 | JavascriptEnvironment();
16 |
17 | v8::Isolate* isolate() const { return isolate_; }
18 | v8::Local context() const {
19 | return v8::Local::New(isolate_, context_);
20 | }
21 |
22 | private:
23 | gin::IsolateHolder isolate_holder_;
24 | v8::Isolate* isolate_;
25 | v8::Isolate::Scope isolate_scope_;
26 | v8::Locker locker_;
27 | v8::HandleScope handle_scope_;
28 | v8::UniquePersistent context_;
29 | v8::Context::Scope context_scope_;
30 |
31 | DISALLOW_COPY_AND_ASSIGN(JavascriptEnvironment);
32 | };
33 |
34 | } // namespace atom
35 |
36 | #endif // ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
37 |
--------------------------------------------------------------------------------
/atom/common/platform_util.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_PLATFORM_UTIL_H_
6 | #define ATOM_COMMON_PLATFORM_UTIL_H_
7 |
8 | class GURL;
9 |
10 | namespace base {
11 | class FilePath;
12 | }
13 |
14 | namespace platform_util {
15 |
16 | // Show the given file in a file manager. If possible, select the file.
17 | // Must be called from the UI thread.
18 | void ShowItemInFolder(const base::FilePath& full_path);
19 |
20 | // Open the given file in the desktop's default manner.
21 | // Must be called from the UI thread.
22 | void OpenItem(const base::FilePath& full_path);
23 |
24 | // Open the given external protocol URL in the desktop's default manner.
25 | // (For example, mailto: URLs in the default mail user agent.)
26 | void OpenExternal(const GURL& url);
27 |
28 | // Move a file to trash.
29 | void MoveItemToTrash(const base::FilePath& full_path);
30 |
31 | void Beep();
32 |
33 | } // namespace platform_util
34 |
35 | #endif // ATOM_COMMON_PLATFORM_UTIL_H_
36 |
--------------------------------------------------------------------------------
/atom/browser/api/lib/app.coffee:
--------------------------------------------------------------------------------
1 | EventEmitter = require('events').EventEmitter
2 |
3 | bindings = process.atomBinding 'app'
4 |
5 | app = bindings.app
6 | app.__proto__ = EventEmitter.prototype
7 |
8 | app.getHomeDir = ->
9 | process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
10 |
11 | app.setApplicationMenu = (menu) ->
12 | require('menu').setApplicationMenu menu
13 |
14 | app.getApplicationMenu = ->
15 | require('menu').getApplicationMenu()
16 |
17 | app.commandLine =
18 | appendSwitch: bindings.appendSwitch,
19 | appendArgument: bindings.appendArgument
20 |
21 | if process.platform is 'darwin'
22 | app.dock =
23 | bounce: (type='informational') -> bindings.dockBounce type
24 | cancelBounce: bindings.dockCancelBounce
25 | setBadge: bindings.dockSetBadgeText
26 | getBadge: bindings.dockGetBadgeText
27 | hide: bindings.dockHide
28 | show: bindings.dockShow
29 |
30 | # Be compatible with old API.
31 | app.once 'ready', -> app.emit 'finish-launching'
32 | app.terminate = app.quit
33 | app.exit = process.exit
34 |
35 | # Only one App object pemitted.
36 | module.exports = app
37 |
--------------------------------------------------------------------------------
/script/compile-coffee.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 | import subprocess
5 | import sys
6 |
7 |
8 | SOURCE_ROOT = os.path.dirname(os.path.dirname(__file__))
9 | WINDOWS_NODE_PATHs = [
10 | 'C:/Program Files/nodejs/node.exe',
11 | 'C:/Program Files (x86)/nodejs/node.exe',
12 | ]
13 |
14 |
15 | def main():
16 | input_file = sys.argv[1]
17 | output_dir = os.path.dirname(sys.argv[2])
18 |
19 | coffee = os.path.join(SOURCE_ROOT, 'node_modules', 'coffee-script', 'bin',
20 | 'coffee')
21 | if sys.platform in ['win32', 'cygwin']:
22 | node = find_node()
23 | if not node:
24 | print 'Node.js is required for building atom-shell'
25 | return 1
26 | subprocess.check_call(['node', coffee, '-c', '-o', output_dir, input_file],
27 | executable=node)
28 | else:
29 | subprocess.check_call(['node', coffee, '-c', '-o', output_dir, input_file])
30 |
31 |
32 | def find_node():
33 | for path in WINDOWS_NODE_PATHs:
34 | if os.path.exists(path):
35 | return path
36 | return None
37 |
38 |
39 | if __name__ == '__main__':
40 | sys.exit(main())
41 |
--------------------------------------------------------------------------------
/atom/common/native_mate_converters/gurl_converter.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_GURL_CONVERTER_H_
6 | #define ATOM_COMMON_NATIVE_MATE_CONVERTERS_GURL_CONVERTER_H_
7 |
8 | #include
9 |
10 | #include "native_mate/converter.h"
11 | #include "url/gurl.h"
12 |
13 | namespace mate {
14 |
15 | template<>
16 | struct Converter {
17 | static v8::Handle ToV8(v8::Isolate* isolate,
18 | const GURL& val) {
19 | return ConvertToV8(isolate, val.spec());
20 | }
21 | static bool FromV8(v8::Isolate* isolate,
22 | v8::Handle val,
23 | GURL* out) {
24 | std::string url;
25 | if (Converter::FromV8(isolate, val, &url)) {
26 | *out = GURL(url);
27 | return true;
28 | } else {
29 | return false;
30 | }
31 | }
32 | };
33 |
34 | } // namespace mate
35 |
36 | #endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_GURL_CONVERTER_H_
37 |
--------------------------------------------------------------------------------
/atom/browser/api/atom_api_menu_views.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "atom/browser/api/atom_api_menu_views.h"
6 |
7 | #include "atom/browser/native_window_views.h"
8 | #include "ui/gfx/screen.h"
9 | #include "ui/views/controls/menu/menu_runner.h"
10 |
11 | namespace atom {
12 |
13 | namespace api {
14 |
15 | MenuViews::MenuViews() {
16 | }
17 |
18 | void MenuViews::Popup(Window* window) {
19 | gfx::Point cursor = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
20 | views::MenuRunner menu_runner(
21 | model(),
22 | views::MenuRunner::CONTEXT_MENU | views::MenuRunner::HAS_MNEMONICS);
23 | ignore_result(menu_runner.RunMenuAt(
24 | static_cast(window->window())->widget(),
25 | NULL,
26 | gfx::Rect(cursor, gfx::Size()),
27 | views::MENU_ANCHOR_TOPLEFT,
28 | ui::MENU_SOURCE_MOUSE));
29 | }
30 |
31 | // static
32 | mate::Wrappable* Menu::Create() {
33 | return new MenuViews();
34 | }
35 |
36 | } // namespace api
37 |
38 | } // namespace atom
39 |
--------------------------------------------------------------------------------
/atom/common/api/atom_api_shell.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include
6 |
7 | #include "atom/common/platform_util.h"
8 | #include "atom/common/native_mate_converters/file_path_converter.h"
9 | #include "atom/common/native_mate_converters/gurl_converter.h"
10 | #include "native_mate/dictionary.h"
11 |
12 | #include "atom/common/node_includes.h"
13 |
14 | namespace {
15 |
16 | void Initialize(v8::Handle exports, v8::Handle unused,
17 | v8::Handle context, void* priv) {
18 | mate::Dictionary dict(context->GetIsolate(), exports);
19 | dict.SetMethod("showItemInFolder", &platform_util::ShowItemInFolder);
20 | dict.SetMethod("openItem", &platform_util::OpenItem);
21 | dict.SetMethod("openExternal", &platform_util::OpenExternal);
22 | dict.SetMethod("moveItemToTrash", &platform_util::MoveItemToTrash);
23 | dict.SetMethod("beep", &platform_util::Beep);
24 | }
25 |
26 | } // namespace
27 |
28 | NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_shell, Initialize)
29 |
--------------------------------------------------------------------------------
/atom/browser/ui/views/win_frame_view.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_UI_VIEWS_WIN_FRAME_VIEW_H_
6 | #define ATOM_BROWSER_UI_VIEWS_WIN_FRAME_VIEW_H_
7 |
8 | #include "atom/browser/ui/views/frameless_view.h"
9 |
10 | namespace atom {
11 |
12 | class WinFrameView : public FramelessView {
13 | public:
14 | WinFrameView();
15 | virtual ~WinFrameView();
16 |
17 | // views::NonClientFrameView:
18 | virtual gfx::Rect GetWindowBoundsForClientBounds(
19 | const gfx::Rect& client_bounds) const OVERRIDE;
20 | virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE;
21 |
22 | // views::View:
23 | virtual gfx::Size GetMinimumSize() const OVERRIDE;
24 | virtual gfx::Size GetMaximumSize() const OVERRIDE;
25 | virtual const char* GetClassName() const OVERRIDE;
26 |
27 | private:
28 | void ClientAreaSizeToWindowSize(gfx::Size* size) const;
29 |
30 | DISALLOW_COPY_AND_ASSIGN(WinFrameView);
31 | };
32 |
33 | } // namespace atom
34 |
35 | #endif // ATOM_BROWSER_UI_VIEWS_WIN_FRAME_VIEW_H_
36 |
--------------------------------------------------------------------------------
/atom/common/common_message_generator.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | // Get basic type definitions.
6 | #define IPC_MESSAGE_IMPL
7 | #include "atom/common/common_message_generator.h"
8 |
9 | // Generate constructors.
10 | #include "ipc/struct_constructor_macros.h"
11 | #include "atom/common/common_message_generator.h"
12 |
13 | // Generate destructors.
14 | #include "ipc/struct_destructor_macros.h"
15 | #include "atom/common/common_message_generator.h"
16 |
17 | // Generate param traits write methods.
18 | #include "ipc/param_traits_write_macros.h"
19 | namespace IPC {
20 | #include "atom/common/common_message_generator.h"
21 | } // namespace IPC
22 |
23 | // Generate param traits read methods.
24 | #include "ipc/param_traits_read_macros.h"
25 | namespace IPC {
26 | #include "atom/common/common_message_generator.h"
27 | } // namespace IPC
28 |
29 | // Generate param traits log methods.
30 | #include "ipc/param_traits_log_macros.h"
31 | namespace IPC {
32 | #include "atom/common/common_message_generator.h"
33 | } // namespace IPC
34 |
35 |
--------------------------------------------------------------------------------
/docs/development/coding-style.md:
--------------------------------------------------------------------------------
1 | # Coding style
2 |
3 | ## C++ and Python
4 |
5 | For C++ and Python, we just follow Chromium's [Coding
6 | Style](http://www.chromium.org/developers/coding-style), there is also a
7 | script `script/cpplint.py` to check whether all files confirm.
8 |
9 | The python's version we are using now is Python 2.7.
10 |
11 | ## CoffeeScript
12 |
13 | For CoffeeScript, we follow GitHub's [Style
14 | Guide](https://github.com/styleguide/javascript), and also following rules:
15 |
16 | * Files should **NOT** end with new line, because we want to match Google's
17 | styles.
18 | * File names should be concatenated with `-` instead of `_`, e.g.
19 | `file-name.coffee` rather than `file_name.coffee`, because in
20 | [github/atom](https://github.com/github/atom) module names are usually in
21 | the `module-name` form, this rule only apply to `.coffee` files.
22 |
23 | ## API Names
24 |
25 | When creating a new API, we should prefer getters and setters instead of
26 | jQuery's one-function style, for example, `.getText()` and `.setText(text)`
27 | are preferred to `.text([text])`. There is a
28 | [discussion](https://github.com/atom/atom-shell/issues/46) of this.
29 |
--------------------------------------------------------------------------------
/docs/api/accelerator.md:
--------------------------------------------------------------------------------
1 | # Accelerator
2 |
3 | An accelerator is string that represents a keyboard shortcut, it can contain
4 | multiple modifiers and key codes, combined by the `+` character.
5 |
6 | Examples:
7 |
8 | * `Command+A`
9 | * `Ctrl+Shift+Z`
10 |
11 | ## Platform notice
12 |
13 | On Linux and Windows, the `Command` key would not have any effect, you can
14 | use `CommandOrControl` which represents `Command` on OS X and `Control` on
15 | Linux and Windows to define some accelerators.
16 |
17 | ## Available modifiers
18 |
19 | * `Command` (or `Cmd` for short)
20 | * `Control` (or `Ctrl` for short)
21 | * `CommandOrControl` (or `CmdOrCtrl` for short)
22 | * `Alt`
23 | * `Shift`
24 |
25 | ## Available key codes
26 |
27 | * `0` to `9`
28 | * `A` to `Z`
29 | * `F1` to `F24`
30 | * Punctuations like `~`, `!`, `@`, `#`, `$`, etc.
31 | * `Space`
32 | * `Backspace`
33 | * `Delete`
34 | * `Insert`
35 | * `Return` (or `Enter` as alias)
36 | * `Up`, `Down`, `Left` and `Right`
37 | * `Home` and `End`
38 | * `PageUp` and `PageDown`
39 | * `Escape` (or `Esc` for short)
40 | * `VolumeUp`, `VolumeDown` and `VolumeMute`
41 | * `MediaNextTrack`, `MediaPreviousTrack`, `MediaStop` and `MediaPlayPause`
42 |
--------------------------------------------------------------------------------
/atom/browser/ui/x/x_window_utils.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "atom/browser/ui/x/x_window_utils.h"
6 |
7 | #include "ui/base/x/x11_util.h"
8 |
9 | namespace atom {
10 |
11 | ::Atom GetAtom(const char* name) {
12 | return XInternAtom(gfx::GetXDisplay(), name, false);
13 | }
14 |
15 | void SetWMSpecState(::Window xwindow, bool enabled, ::Atom state) {
16 | XEvent xclient;
17 | memset(&xclient, 0, sizeof(xclient));
18 | xclient.type = ClientMessage;
19 | xclient.xclient.window = xwindow;
20 | xclient.xclient.message_type = GetAtom("_NET_WM_STATE");
21 | xclient.xclient.format = 32;
22 | xclient.xclient.data.l[0] = enabled ? 1 : 0;
23 | xclient.xclient.data.l[1] = state;
24 | xclient.xclient.data.l[2] = None;
25 | xclient.xclient.data.l[3] = 1;
26 | xclient.xclient.data.l[4] = 0;
27 |
28 | XDisplay* xdisplay = gfx::GetXDisplay();
29 | XSendEvent(xdisplay, DefaultRootWindow(xdisplay), False,
30 | SubstructureRedirectMask | SubstructureNotifyMask,
31 | &xclient);
32 | }
33 |
34 | } // namespace atom
35 |
--------------------------------------------------------------------------------
/atom/common/api/atom_bindings.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_API_ATOM_BINDINGS_H_
6 | #define ATOM_COMMON_API_ATOM_BINDINGS_H_
7 |
8 | #include
9 |
10 | #include "base/strings/string16.h"
11 | #include "v8/include/v8.h"
12 | #include "vendor/node/deps/uv/include/uv.h"
13 |
14 | namespace node {
15 | class Environment;
16 | }
17 |
18 | namespace atom {
19 |
20 | class AtomBindings {
21 | public:
22 | AtomBindings();
23 | virtual ~AtomBindings();
24 |
25 | // Add process.atomBinding function, which behaves like process.binding but
26 | // load native code from atom-shell instead.
27 | virtual void BindTo(v8::Isolate* isolate, v8::Handle process);
28 |
29 | private:
30 | void ActivateUVLoop(v8::Isolate* isolate);
31 |
32 | static void OnCallNextTick(uv_async_t* handle);
33 |
34 | uv_async_t call_next_tick_async_;
35 | std::list pending_next_ticks_;
36 |
37 | DISALLOW_COPY_AND_ASSIGN(AtomBindings);
38 | };
39 |
40 | } // namespace atom
41 |
42 | #endif // ATOM_COMMON_API_ATOM_BINDINGS_H_
43 |
--------------------------------------------------------------------------------
/atom/browser/api/atom_api_power_monitor.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
6 | #define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
7 |
8 | #include "atom/browser/api/event_emitter.h"
9 | #include "base/compiler_specific.h"
10 | #include "base/power_monitor/power_observer.h"
11 | #include "native_mate/handle.h"
12 |
13 | namespace atom {
14 |
15 | namespace api {
16 |
17 | class PowerMonitor : public mate::EventEmitter,
18 | public base::PowerObserver {
19 | public:
20 | static mate::Handle Create(v8::Isolate* isolate);
21 |
22 | protected:
23 | PowerMonitor();
24 | virtual ~PowerMonitor();
25 |
26 | // base::PowerObserver implementations:
27 | virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE;
28 | virtual void OnSuspend() OVERRIDE;
29 | virtual void OnResume() OVERRIDE;
30 |
31 | private:
32 | DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
33 | };
34 |
35 | } // namespace api
36 |
37 | } // namespace atom
38 |
39 | #endif // ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
40 |
--------------------------------------------------------------------------------
/atom/browser/net/url_request_string_job.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "atom/browser/net/url_request_string_job.h"
6 |
7 | #include
8 |
9 | #include "net/base/net_errors.h"
10 |
11 | namespace atom {
12 |
13 | URLRequestStringJob::URLRequestStringJob(net::URLRequest* request,
14 | net::NetworkDelegate* network_delegate,
15 | const std::string& mime_type,
16 | const std::string& charset,
17 | const std::string& data)
18 | : net::URLRequestSimpleJob(request, network_delegate),
19 | mime_type_(mime_type),
20 | charset_(charset),
21 | data_(data) {
22 | }
23 |
24 | int URLRequestStringJob::GetData(
25 | std::string* mime_type,
26 | std::string* charset,
27 | std::string* data,
28 | const net::CompletionCallback& callback) const {
29 | *mime_type = mime_type_;
30 | *charset = charset_;
31 | *data = data_;
32 | return net::OK;
33 | }
34 |
35 | } // namespace atom
36 |
--------------------------------------------------------------------------------
/atom/browser/ui/cocoa/event_processing_window.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_UI_COCOA_EVENT_PROCESSING_WINDOW_H_
6 | #define ATOM_BROWSER_UI_COCOA_EVENT_PROCESSING_WINDOW_H_
7 |
8 | #import
9 |
10 | // Override NSWindow to access unhandled keyboard events (for command
11 | // processing); subclassing NSWindow is the only method to do
12 | // this.
13 | @interface EventProcessingWindow : NSWindow {
14 | @private
15 | BOOL redispatchingEvent_;
16 | BOOL eventHandled_;
17 | }
18 |
19 | // Sends a key event to |NSApp sendEvent:|, but also makes sure that it's not
20 | // short-circuited to the RWHV. This is used to send keyboard events to the menu
21 | // and the cmd-` handler if a keyboard event comes back unhandled from the
22 | // renderer. The event must be of type |NSKeyDown|, |NSKeyUp|, or
23 | // |NSFlagsChanged|.
24 | // Returns |YES| if |event| has been handled.
25 | - (BOOL)redispatchKeyEvent:(NSEvent*)event;
26 |
27 | - (BOOL)performKeyEquivalent:(NSEvent*)theEvent;
28 | @end
29 |
30 | #endif // ATOM_BROWSER_UI_COCOA_EVENT_PROCESSING_WINDOW_H_
31 |
--------------------------------------------------------------------------------
/atom/common/native_mate_converters/string16_converter.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_STRING16_CONVERTER_H_
6 | #define ATOM_COMMON_NATIVE_MATE_CONVERTERS_STRING16_CONVERTER_H_
7 |
8 | #include "base/strings/string16.h"
9 | #include "native_mate/converter.h"
10 |
11 | namespace mate {
12 |
13 | template<>
14 | struct Converter {
15 | static v8::Handle ToV8(v8::Isolate* isolate,
16 | const base::string16& val) {
17 | return MATE_STRING_NEW_FROM_UTF16(
18 | isolate, reinterpret_cast(val.data()), val.size());
19 | }
20 | static bool FromV8(v8::Isolate* isolate,
21 | v8::Handle val,
22 | base::string16* out) {
23 | if (!val->IsString())
24 | return false;
25 |
26 | v8::String::Value s(val);
27 | out->assign(reinterpret_cast(*s), s.length());
28 | return true;
29 | }
30 | };
31 |
32 | } // namespace mate
33 |
34 | #endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_STRING16_CONVERTER_H_
35 |
--------------------------------------------------------------------------------
/atom/renderer/api/atom_renderer_bindings.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
6 | #define ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
7 |
8 | #include "atom/common/api/atom_bindings.h"
9 |
10 | #include "base/strings/string16.h"
11 |
12 | namespace base {
13 | class ListValue;
14 | }
15 |
16 | namespace content {
17 | class RenderView;
18 | }
19 |
20 | namespace blink {
21 | class WebFrame;
22 | }
23 |
24 | namespace atom {
25 |
26 | class AtomRendererBindings : public AtomBindings {
27 | public:
28 | AtomRendererBindings();
29 | virtual ~AtomRendererBindings();
30 |
31 | // Call BindTo for process object of the frame.
32 | void BindToFrame(blink::WebFrame* frame);
33 |
34 | // Dispatch messages from browser.
35 | void OnBrowserMessage(content::RenderView* render_view,
36 | const base::string16& channel,
37 | const base::ListValue& args);
38 |
39 | private:
40 | DISALLOW_COPY_AND_ASSIGN(AtomRendererBindings);
41 | };
42 |
43 | } // namespace atom
44 |
45 | #endif // ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
46 |
--------------------------------------------------------------------------------
/atom/common/api/lib/crash-reporter.coffee:
--------------------------------------------------------------------------------
1 | {spawn} = require 'child_process'
2 | binding = process.atomBinding 'crash_reporter'
3 |
4 | class CrashReporter
5 | start: (options={}) ->
6 | {productName, companyName, submitUrl, autoSubmit, ignoreSystemCrashHandler, extra} = options
7 |
8 | productName ?= 'Atom-Shell'
9 | companyName ?= 'GitHub, Inc'
10 | submitUrl ?= 'http://54.249.141.255:1127/post'
11 | autoSubmit ?= true
12 | ignoreSystemCrashHandler ?= false
13 | extra ?= {}
14 |
15 | extra._productName ?= productName
16 | extra._companyName ?= companyName
17 | extra._version ?=
18 | if process.type is 'browser'
19 | require('app').getVersion()
20 | else
21 | require('remote').require('app').getVersion()
22 |
23 | start = -> binding.start productName, companyName, submitUrl, autoSubmit, ignoreSystemCrashHandler, extra
24 |
25 | if process.platform is 'win32'
26 | args = [
27 | "--reporter-url=#{submitUrl}"
28 | "--application-name=#{productName}"
29 | "--v=1"
30 | ]
31 | env = ATOM_SHELL_INTERNAL_CRASH_SERVICE: 1
32 |
33 | spawn process.execPath, args, {env, detached: true}
34 | start()
35 | else
36 | start()
37 |
38 | module.exports = new CrashReporter
39 |
--------------------------------------------------------------------------------
/atom/common/asar/scoped_temporary_file.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_ASAR_SCOPED_TEMPORARY_FILE_H_
6 | #define ATOM_COMMON_ASAR_SCOPED_TEMPORARY_FILE_H_
7 |
8 | #include "base/files/file_path.h"
9 |
10 | namespace asar {
11 |
12 | // An object representing a temporary file that should be cleaned up when this
13 | // object goes out of scope. Note that since deletion occurs during the
14 | // destructor, no further error handling is possible if the directory fails to
15 | // be deleted. As a result, deletion is not guaranteed by this class.
16 | class ScopedTemporaryFile {
17 | public:
18 | ScopedTemporaryFile();
19 | virtual ~ScopedTemporaryFile();
20 |
21 | // Init an empty temporary file.
22 | bool Init();
23 |
24 | // Init an temporary file and fill it with content of |path|.
25 | bool InitFromFile(const base::FilePath& path, uint64 offset, uint64 size);
26 |
27 | base::FilePath path() const { return path_; }
28 |
29 | private:
30 | base::FilePath path_;
31 |
32 | DISALLOW_COPY_AND_ASSIGN(ScopedTemporaryFile);
33 | };
34 |
35 | } // namespace asar
36 |
37 | #endif // ATOM_COMMON_ASAR_SCOPED_TEMPORARY_FILE_H_
38 |
--------------------------------------------------------------------------------
/atom/browser/atom_javascript_dialog_manager.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #include "atom/browser/atom_javascript_dialog_manager.h"
6 |
7 | #include
8 |
9 | #include "base/strings/utf_string_conversions.h"
10 |
11 | namespace atom {
12 |
13 | void AtomJavaScriptDialogManager::RunJavaScriptDialog(
14 | content::WebContents* web_contents,
15 | const GURL& origin_url,
16 | const std::string& accept_lang,
17 | content::JavaScriptMessageType javascript_message_type,
18 | const base::string16& message_text,
19 | const base::string16& default_prompt_text,
20 | const DialogClosedCallback& callback,
21 | bool* did_suppress_message) {
22 | callback.Run(false, base::string16());
23 | }
24 |
25 | void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
26 | content::WebContents* web_contents,
27 | const base::string16& message_text,
28 | bool is_reload,
29 | const DialogClosedCallback& callback) {
30 |
31 | bool prevent_reload = message_text.empty() ||
32 | message_text == base::ASCIIToUTF16("false");
33 | callback.Run(!prevent_reload, message_text);
34 | }
35 |
36 | } // namespace atom
37 |
--------------------------------------------------------------------------------
/script/build.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import argparse
4 | import os
5 | import subprocess
6 | import sys
7 |
8 |
9 | CONFIGURATIONS = ['Release', 'Debug']
10 | SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
11 |
12 |
13 | def main():
14 | os.chdir(SOURCE_ROOT)
15 |
16 | ninja = os.path.join('vendor', 'depot_tools', 'ninja')
17 | if sys.platform == 'win32':
18 | ninja += '.exe'
19 |
20 | args = parse_args()
21 | for config in args.configuration:
22 | build_path = os.path.join('out', config)
23 | ret = subprocess.call([ninja, '-C', build_path, args.target])
24 | if ret != 0:
25 | sys.exit(ret)
26 |
27 |
28 | def parse_args():
29 | parser = argparse.ArgumentParser(description='Build atom-shell')
30 | parser.add_argument('-c', '--configuration',
31 | help='Build with Release or Debug configuration',
32 | nargs='+',
33 | default=CONFIGURATIONS,
34 | required=False)
35 | parser.add_argument('-t', '--target',
36 | help='Build specified target',
37 | default='atom',
38 | required=False)
39 | return parser.parse_args()
40 |
41 |
42 | if __name__ == '__main__':
43 | sys.exit(main())
44 |
--------------------------------------------------------------------------------
/atom/browser/native_window_observer.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_NATIVE_WINDOW_OBSERVER_H_
6 | #define ATOM_BROWSER_NATIVE_WINDOW_OBSERVER_H_
7 |
8 | #include
9 |
10 | namespace atom {
11 |
12 | class NativeWindowObserver {
13 | public:
14 | virtual ~NativeWindowObserver() {}
15 |
16 | // Called when the web page of the window has updated it's document title.
17 | virtual void OnPageTitleUpdated(bool* prevent_default,
18 | const std::string& title) {}
19 |
20 | // Called when the window is gonna closed.
21 | virtual void WillCloseWindow(bool* prevent_default) {}
22 |
23 | // Called when the window is closed.
24 | virtual void OnWindowClosed() {}
25 |
26 | // Called when window loses focus.
27 | virtual void OnWindowBlur() {}
28 |
29 | // Called when window gains focus.
30 | virtual void OnWindowFocus() {}
31 |
32 | // Called when renderer is hung.
33 | virtual void OnRendererUnresponsive() {}
34 |
35 | // Called when renderer recovers.
36 | virtual void OnRendererResponsive() {}
37 | };
38 |
39 | } // namespace atom
40 |
41 | #endif // ATOM_BROWSER_NATIVE_WINDOW_OBSERVER_H_
42 |
--------------------------------------------------------------------------------
/atom/browser/net/url_request_string_job.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_NET_URL_REQUEST_STRING_JOB_H_
6 | #define ATOM_BROWSER_NET_URL_REQUEST_STRING_JOB_H_
7 |
8 | #include "net/url_request/url_request_simple_job.h"
9 |
10 | #include
11 |
12 | namespace atom {
13 |
14 | class URLRequestStringJob : public net::URLRequestSimpleJob {
15 | public:
16 | URLRequestStringJob(net::URLRequest* request,
17 | net::NetworkDelegate* network_delegate,
18 | const std::string& mime_type,
19 | const std::string& charset,
20 | const std::string& data);
21 |
22 | // URLRequestSimpleJob:
23 | virtual int GetData(std::string* mime_type,
24 | std::string* charset,
25 | std::string* data,
26 | const net::CompletionCallback& callback) const OVERRIDE;
27 |
28 | private:
29 | std::string mime_type_;
30 | std::string charset_;
31 | std::string data_;
32 |
33 | DISALLOW_COPY_AND_ASSIGN(URLRequestStringJob);
34 | };
35 |
36 | } // namespace atom
37 |
38 | #endif // ATOM_BROWSER_NET_URL_REQUEST_STRING_JOB_H_
39 |
--------------------------------------------------------------------------------
/atom/common/native_mate_converters/file_path_converter.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_FILE_PATH_CONVERTER_H_
6 | #define ATOM_COMMON_NATIVE_MATE_CONVERTERS_FILE_PATH_CONVERTER_H_
7 |
8 | #include
9 |
10 | #include "atom/common/native_mate_converters/string16_converter.h"
11 | #include "base/files/file_path.h"
12 |
13 | namespace mate {
14 |
15 | template<>
16 | struct Converter {
17 | static v8::Handle ToV8(v8::Isolate* isolate,
18 | const base::FilePath& val) {
19 | return Converter::ToV8(isolate, val.value());
20 | }
21 | static bool FromV8(v8::Isolate* isolate,
22 | v8::Handle val,
23 | base::FilePath* out) {
24 | base::FilePath::StringType path;
25 | if (Converter::FromV8(isolate, val, &path)) {
26 | *out = base::FilePath(path);
27 | return true;
28 | } else {
29 | return false;
30 | }
31 | }
32 | };
33 |
34 | } // namespace mate
35 |
36 | #endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_FILE_PATH_CONVERTER_H_
37 |
--------------------------------------------------------------------------------
/atom/common/api/object_life_monitor.cc:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Copyright (c) 2012 Intel Corp. All rights reserved.
3 | // Use of this source code is governed by the MIT license that can be
4 | // found in the LICENSE file.
5 |
6 | #include "atom/common/api/object_life_monitor.h"
7 |
8 | #include "native_mate/compat.h"
9 |
10 | namespace atom {
11 |
12 | // static
13 | void ObjectLifeMonitor::BindTo(v8::Isolate* isolate,
14 | v8::Handle target,
15 | v8::Handle destructor) {
16 | target->SetHiddenValue(MATE_STRING_NEW(isolate, "destructor"), destructor);
17 |
18 | ObjectLifeMonitor* olm = new ObjectLifeMonitor();
19 | olm->handle_.reset(isolate, target);
20 | olm->handle_.SetWeak(olm, WeakCallback);
21 | }
22 |
23 | ObjectLifeMonitor::ObjectLifeMonitor() {
24 | }
25 |
26 | // static
27 | void ObjectLifeMonitor::WeakCallback(
28 | const v8::WeakCallbackData& data) {
29 | // destructor.call(object, object);
30 | v8::Local obj = data.GetValue();
31 | v8::Local::Cast(obj->GetHiddenValue(
32 | MATE_STRING_NEW(data.GetIsolate(), "destructor")))->Call(obj, 0, NULL);
33 | delete data.GetParameter();
34 | }
35 |
36 | } // namespace atom
37 |
--------------------------------------------------------------------------------
/atom/browser/ui/tray_icon_gtk.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2014 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_UI_TRAY_ICON_GTK_H_
6 | #define ATOM_BROWSER_UI_TRAY_ICON_GTK_H_
7 |
8 | #include
9 |
10 | #include "atom/browser/ui/tray_icon.h"
11 | #include "ui/views/linux_ui/status_icon_linux.h"
12 |
13 | namespace views {
14 | class StatusIconLinux;
15 | }
16 |
17 | namespace atom {
18 |
19 | class TrayIconGtk : public TrayIcon,
20 | public views::StatusIconLinux::Delegate {
21 | public:
22 | TrayIconGtk();
23 | virtual ~TrayIconGtk();
24 |
25 | // TrayIcon:
26 | virtual void SetImage(const gfx::ImageSkia& image) OVERRIDE;
27 | virtual void SetPressedImage(const gfx::ImageSkia& image) OVERRIDE;
28 | virtual void SetToolTip(const std::string& tool_tip) OVERRIDE;
29 | virtual void SetContextMenu(ui::SimpleMenuModel* menu_model) OVERRIDE;
30 |
31 | private:
32 | // views::StatusIconLinux::Delegate:
33 | virtual void OnClick() OVERRIDE;
34 | virtual bool HasClickAction() OVERRIDE;
35 |
36 | scoped_ptr icon_;
37 |
38 | DISALLOW_COPY_AND_ASSIGN(TrayIconGtk);
39 | };
40 |
41 | } // namespace atom
42 |
43 | #endif // ATOM_BROWSER_UI_TRAY_ICON_GTK_H_
44 |
--------------------------------------------------------------------------------
/chromium_src/chrome/browser/browser_process.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style license that can be
3 | // found in the LICENSE file.
4 |
5 | // This interface is for managing the global services of the application. Each
6 | // service is lazily created when requested the first time. The service getters
7 | // will return NULL if the service is not available, so callers must check for
8 | // this condition.
9 |
10 | #ifndef CHROME_BROWSER_BROWSER_PROCESS_H_
11 | #define CHROME_BROWSER_BROWSER_PROCESS_H_
12 |
13 | #include
14 |
15 | #include "base/basictypes.h"
16 | #include "base/memory/scoped_ptr.h"
17 |
18 | namespace printing {
19 | class PrintJobManager;
20 | }
21 |
22 | // NOT THREAD SAFE, call only from the main thread.
23 | // These functions shouldn't return NULL unless otherwise noted.
24 | class BrowserProcess {
25 | public:
26 | BrowserProcess();
27 | ~BrowserProcess();
28 |
29 | std::string GetApplicationLocale();
30 |
31 | printing::PrintJobManager* print_job_manager();
32 |
33 | private:
34 | scoped_ptr print_job_manager_;
35 |
36 | DISALLOW_COPY_AND_ASSIGN(BrowserProcess);
37 | };
38 |
39 | extern BrowserProcess* g_browser_process;
40 |
41 | #endif // CHROME_BROWSER_BROWSER_PROCESS_H_
42 |
--------------------------------------------------------------------------------
/spec/modules-spec.coffee:
--------------------------------------------------------------------------------
1 | assert = require 'assert'
2 | fs = require 'fs'
3 | path = require 'path'
4 | temp = require 'temp'
5 |
6 | describe 'third-party module', ->
7 | fixtures = path.join __dirname, 'fixtures'
8 | temp.track()
9 |
10 | describe 'runas', ->
11 | it 'can be required in renderer', ->
12 | require 'runas'
13 |
14 | it 'can be required in node binary', (done) ->
15 | runas = path.join fixtures, 'module', 'runas.js'
16 | child = require('child_process').fork runas
17 | child.on 'message', (msg) ->
18 | assert.equal msg, 'ok'
19 | done()
20 |
21 | describe 'pathwatcher', ->
22 | it 'emits file events correctly', (done) ->
23 | pathwatcher = require 'pathwatcher'
24 | temp.mkdir 'dir', (err, dir) ->
25 | return done() if err
26 | file = path.join dir, 'file'
27 | fs.writeFileSync file, 'content'
28 | watcher = pathwatcher.watch file, (event) ->
29 | assert.equal event, 'change'
30 | watcher.close()
31 | done()
32 | fs.writeFileSync file, 'content2'
33 |
34 | describe 'q', ->
35 | Q = require 'q'
36 |
37 | describe 'Q.when', ->
38 | it 'emits the fullfil callback', (done) ->
39 | Q(true).then (val) ->
40 | assert.equal val, true
41 | done()
42 |
--------------------------------------------------------------------------------
/docs/development/build-instructions-mac.md:
--------------------------------------------------------------------------------
1 | # Build instructions (Mac)
2 |
3 | ## Prerequisites
4 |
5 | * Mac OS X >= 10.8
6 | * [Xcode](https://developer.apple.com/technologies/tools/) >= 5.1
7 | * [node.js](http://nodejs.org) (external).
8 |
9 | If you are using the python downloaded by Homebrew, you also need to install
10 | following python modules:
11 |
12 | * pyobjc
13 |
14 | ## Getting the code
15 |
16 | ```bash
17 | $ git clone https://github.com/atom/atom-shell.git
18 | ```
19 |
20 | ## Bootstrapping
21 |
22 | The bootstrap script will download all necessary build dependencies and create
23 | build project files. Notice that we're using `ninja` to build `atom-shell` so
24 | there is no Xcode project generated.
25 |
26 | ```bash
27 | $ cd atom-shell
28 | $ ./script/bootstrap.py
29 | ```
30 |
31 | ## Building
32 |
33 | Build both `Release` and `Debug` targets:
34 |
35 | ```bash
36 | $ ./script/build.py
37 | ```
38 |
39 | You can also only build the `Debug` target:
40 |
41 | ```bash
42 | $ ./script/build.py -c Debug
43 | ```
44 |
45 | After building is done, you can find `Atom.app` under `out/Debug`.
46 |
47 | ## 32bit support
48 |
49 | Currently atom-shell can only be built for 64bit target on OS X, and there is no
50 | plan to support 32bit on OS X in future.
51 |
52 | ## Tests
53 |
54 | ```bash
55 | $ ./script/test.py
56 | ```
57 |
--------------------------------------------------------------------------------
/atom/browser/ui/accelerator_util.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2013 GitHub, Inc. All rights reserved.
2 | // Use of this source code is governed by the MIT license that can be
3 | // found in the LICENSE file.
4 |
5 | #ifndef ATOM_BROWSER_UI_ACCELERATOR_UTIL_H_
6 | #define ATOM_BROWSER_UI_ACCELERATOR_UTIL_H_
7 |
8 | #include