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

Use native_mate to simplify dialog api.

Browse source
This commit is contained in:
Cheng Zhao 2014-04-16 15:14:44 +08:00
commit aa1efe70e2
10 changed files with 189 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

1
atom.gyp
View file

@ -51,7 +51,6 @@
'atom/browser/api/atom_api_browser_ipc.cc',
'atom/browser/api/atom_api_browser_ipc.h',
'atom/browser/api/atom_api_dialog.cc',
'atom/browser/api/atom_api_dialog.h',
'atom/browser/api/atom_api_event.cc',
'atom/browser/api/atom_api_event.h',
'atom/browser/api/atom_api_menu.cc',

201
atom/browser/api/atom_api_dialog.cc
View file

@ -2,143 +2,174 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "atom/browser/api/atom_api_dialog.h"
#include <string>
#include <vector>
#include "base/bind.h"
#include "atom/browser/api/atom_api_window.h"
#include "atom/browser/native_window.h"
#include "atom/browser/ui/file_dialog.h"
#include "atom/browser/ui/message_box.h"
#include "atom/common/v8_converters/file_path_converter.h"
#include "native_mate/dictionary.h"
#include "native_mate/scoped_persistent.h"
#include "atom/common/v8/node_common.h"
#include "atom/common/v8/native_type_conversions.h"
namespace atom {
namespace mate {
template<>
struct Converter<atom::NativeWindow*> {
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
atom::NativeWindow** out) {
using atom::api::Window;
if (val->IsNull()) {
*out = NULL;
return true; // NULL is a valid value for NativeWindow*.
} else if (val->IsObject()) {
Window* window = Window::Unwrap<Window>(val->ToObject());
*out = window->window();
return true;
} else {
return false;
}
}
};
typedef scoped_refptr<RefCountedPersistent<v8::Function>> RefCountedV8Function;
template<>
struct Converter<mate::RefCountedV8Function> {
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
RefCountedV8Function* out) {
if (!val->IsFunction())
return false;
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(val);
*out = new mate::RefCountedPersistent<v8::Function>(function);
return true;
}
};
} // namespace mate
namespace api {
namespace {
template<typename T>
void CallV8Function(const RefCountedV8Function& callback, T arg) {
void CallV8Function(const mate::RefCountedV8Function& callback, T arg) {
v8::Locker locker(node_isolate);
v8::HandleScope handle_scope(node_isolate);
v8::Handle<v8::Value> value = ToV8Value(arg);
v8::Handle<v8::Value> value = mate::Converter<T>::ToV8(node_isolate, arg);
callback->NewHandle(node_isolate)->Call(
v8::Context::GetCurrent()->Global(), 1, &value);
}
template<typename T>
void CallV8Function2(const RefCountedV8Function& callback, bool result, T arg) {
void CallV8Function2(
const mate::RefCountedV8Function& callback, bool result, const T& arg) {
if (result)
return CallV8Function<T>(callback, arg);
else
return CallV8Function<void*>(callback, NULL);
}
void Initialize(v8::Handle<v8::Object> target) {
NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
NODE_SET_METHOD(target, "showSaveDialog", ShowSaveDialog);
}
} // namespace
void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args) {
int type;
std::vector<std::string> buttons;
std::string title, message, detail;
if (!FromV8Arguments(args, &type, &buttons, &title, &message, &detail))
return node::ThrowTypeError("Bad argument");
NativeWindow* native_window = FromV8Value(args[5]);
if (!args[6]->IsFunction()) {
int chosen = atom::ShowMessageBox(
native_window,
(MessageBoxType)type,
buttons,
title,
message,
detail);
args.GetReturnValue().Set(chosen);
} else {
RefCountedV8Function callback = FromV8Value(args[6]);
void ShowMessageBox(int type,
const std::vector<std::string>& buttons,
const std::string& title,
const std::string& message,
const std::string& detail,
atom::NativeWindow* window,
mate::Arguments* args) {
v8::Handle<v8::Value> peek = args->PeekNext();
mate::RefCountedV8Function callback;
if (mate::Converter<mate::RefCountedV8Function>::FromV8(node_isolate,
peek,
&callback)) {
atom::ShowMessageBox(
native_window,
(MessageBoxType)type,
window,
(atom::MessageBoxType)type,
buttons,
title,
message,
detail,
base::Bind(&CallV8Function<int>, callback));
} else {
int chosen = atom::ShowMessageBox(
window,
(atom::MessageBoxType)type,
buttons,
title,
message,
detail);
args->Return(chosen);
}
}
void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string title;
base::FilePath default_path;
int properties;
if (!FromV8Arguments(args, &title, &default_path, &properties))
return node::ThrowTypeError("Bad argument");
NativeWindow* native_window = FromV8Value(args[3]);
if (!args[4]->IsFunction()) {
std::vector<base::FilePath> paths;
if (!file_dialog::ShowOpenDialog(native_window,
title,
default_path,
properties,
&paths))
return;
v8::Handle<v8::Array> result = v8::Array::New(paths.size());
for (size_t i = 0; i < paths.size(); ++i)
result->Set(i, ToV8Value(paths[i]));
args.GetReturnValue().Set(result);
} else {
RefCountedV8Function callback = FromV8Value(args[4]);
void ShowOpenDialog(const std::string& title,
const base::FilePath& default_path,
int properties,
atom::NativeWindow* window,
mate::Arguments* args) {
v8::Handle<v8::Value> peek = args->PeekNext();
mate::RefCountedV8Function callback;
if (mate::Converter<mate::RefCountedV8Function>::FromV8(node_isolate,
peek,
&callback)) {
file_dialog::ShowOpenDialog(
native_window,
window,
title,
default_path,
properties,
base::Bind(&CallV8Function2<const std::vector<base::FilePath>&>,
base::Bind(&CallV8Function2<std::vector<base::FilePath>>,
callback));
} else {
std::vector<base::FilePath> paths;
if (file_dialog::ShowOpenDialog(window,
title,
default_path,
properties,
&paths))
args->Return(paths);
}
}
void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
std::string title;
base::FilePath default_path;
if (!FromV8Arguments(args, &title, &default_path))
return node::ThrowTypeError("Bad argument");
NativeWindow* native_window = FromV8Value(args[2]);
if (!args[3]->IsFunction()) {
void ShowSaveDialog(const std::string& title,
const base::FilePath& default_path,
atom::NativeWindow* window,
mate::Arguments* args) {
v8::Handle<v8::Value> peek = args->PeekNext();
mate::RefCountedV8Function callback;
if (mate::Converter<mate::RefCountedV8Function>::FromV8(node_isolate,
peek,
&callback)) {
file_dialog::ShowSaveDialog(
window,
title,
default_path,
base::Bind(&CallV8Function2<base::FilePath>, callback));
} else {
base::FilePath path;
if (file_dialog::ShowSaveDialog(native_window,
if (file_dialog::ShowSaveDialog(window,
title,
default_path,
&path))
args.GetReturnValue().Set(ToV8Value(path));
} else {
RefCountedV8Function callback = FromV8Value(args[3]);
file_dialog::ShowSaveDialog(
native_window,
title,
default_path,
base::Bind(&CallV8Function2<const base::FilePath&>, callback));
args->Return(path);
}
}
} // namespace api
void Initialize(v8::Handle<v8::Object> exports) {
mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
dict.SetMethod("showMessageBox", &ShowMessageBox);
dict.SetMethod("showOpenDialog", &ShowOpenDialog);
dict.SetMethod("showSaveDialog", &ShowSaveDialog);
}
} // namespace atom
} // namespace
NODE_MODULE(atom_browser_dialog, atom::api::Initialize)
NODE_MODULE(atom_browser_dialog, Initialize)

22
atom/browser/api/atom_api_dialog.h
View file

@ -1,22 +0,0 @@
// Copyright (c) 2013 GitHub, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_BROWSER_API_ATOM_API_DIALOG_H_
#define ATOM_BROWSER_API_ATOM_API_DIALOG_H_
#include "v8/include/v8.h"
namespace atom {
namespace api {
void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args);
void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
} // namespace api
} // namespace atom
#endif // ATOM_BROWSER_API_ATOM_API_DIALOG_H_

2
atom/common/api/atom_api_id_weak_map.cc
View file

@ -28,7 +28,7 @@ int32_t IDWeakMap::Add(v8::Isolate* isolate, v8::Handle<v8::Object> object) {
object->SetHiddenValue(mate::StringToV8(isolate, "IDWeakMapKey"),
mate::Converter<int32_t>::ToV8(isolate, key));
map_[key] = new RefCountedPersistent<v8::Object>(object);
map_[key] = new mate::RefCountedPersistent<v8::Object>(object);
map_[key]->MakeWeak(this, WeakCallback);
return key;
}

5
atom/common/api/atom_api_id_weak_map.h
View file

@ -9,8 +9,8 @@
#include <map>
#include <vector>
#include "atom/common/v8/scoped_persistent.h"
#include "base/basictypes.h"
#include "native_mate/scoped_persistent.h"
#include "native_mate/wrappable.h"
namespace atom {
@ -40,6 +40,9 @@ class IDWeakMap : public mate::Wrappable {
IDWeakMap* self);
int32_t next_id_;
typedef scoped_refptr<mate::RefCountedPersistent<v8::Object> >
RefCountedV8Object;
std::map<int32_t, RefCountedV8Object> map_;
DISALLOW_COPY_AND_ASSIGN(IDWeakMap);

17
atom/common/api/atom_api_shell.cc
View file

@ -5,7 +5,7 @@
#include <string>
#include "atom/common/platform_util.h"
#include "base/files/file_path.h"
#include "atom/common/v8_converters/file_path_converter.h"
#include "native_mate/object_template_builder.h"
#include "url/gurl.h"
@ -28,21 +28,6 @@ struct Converter<GURL> {
}
};
template<>
struct Converter<base::FilePath> {
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
base::FilePath* out) {
std::string path;
if (Converter<std::string>::FromV8(isolate, val, &path)) {
*out = base::FilePath::FromUTF8Unsafe(path);
return true;
} else {
return false;
}
}
};
} // namespace mate
namespace {

34
atom/common/v8_converters/file_path_converter.h Normal file
View file

@ -0,0 +1,34 @@
// Copyright (c) 2014 GitHub, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_COMMON_V8_CONVERTERS_FILE_PATH_CONVERTER_H_
#define ATOM_COMMON_V8_CONVERTERS_FILE_PATH_CONVERTER_H_
#include "atom/common/v8_converters/string16_converter.h"
#include "base/files/file_path.h"
namespace mate {
template<>
struct Converter<base::FilePath> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
const base::FilePath& val) {
return Converter<base::FilePath::StringType>::ToV8(isolate, val.value());
}
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
base::FilePath* out) {
std::string path;
if (Converter<std::string>::FromV8(isolate, val, &path)) {
*out = base::FilePath::FromUTF8Unsafe(path);
return true;
} else {
return false;
}
}
};
} // namespace mate
#endif // ATOM_COMMON_V8_CONVERTERS_FILE_PATH_CONVERTER_H_

31
atom/common/v8_converters/string16_converter.h Normal file
View file

@ -0,0 +1,31 @@
// Copyright (c) 2014 GitHub, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ATOM_COMMON_V8_CONVERTERS_STRING16_CONVERTER_H_
#define ATOM_COMMON_V8_CONVERTERS_STRING16_CONVERTER_H_
#include "base/strings/string16.h"
#include "native_mate/converter.h"
namespace mate {
template<>
struct Converter<string16> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
const string16& val) {
return v8::String::New(reinterpret_cast<const uint16_t*>(val.data()),
val.size());
}
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
string16* out) {
v8::String::Value s(val);
*out = string16(reinterpret_cast<const char16*>(*s), s.length());
return true;
}
};
} // namespace mate
#endif // ATOM_COMMON_V8_CONVERTERS_STRING16_CONVERTER_H_

17
atom/renderer/api/atom_api_renderer_ipc.cc
View file

@ -4,6 +4,7 @@
#include "atom/common/api/api_messages.h"
#include "atom/common/v8/v8_value_converter.h"
#include "atom/common/v8_converters/string16_converter.h"
#include "content/public/renderer/render_view.h"
#include "native_mate/object_template_builder.h"
#include "third_party/WebKit/public/web/WebFrame.h"
@ -17,22 +18,6 @@ using WebKit::WebView;
namespace mate {
template<>
struct Converter<string16> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
const string16& val) {
return v8::String::New(reinterpret_cast<const uint16_t*>(val.data()),
val.size());
}
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
string16* out) {
v8::String::Value s(val);
*out = string16(reinterpret_cast<const char16*>(*s), s.length());
return true;
}
};
template<>
struct Converter<base::ListValue> {
static bool FromV8(v8::Isolate* isolate,

2
vendor/native_mate vendored

@ -1 +1 @@
Subproject commit ace550d6b20a62ca1101153a06bccb4ba1484a14
Subproject commit c9fa29ef640e8d3d2edf6b48c2311b16ce314464