230 lines
6.4 KiB
C++
230 lines
6.4 KiB
C++
// 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.
|
|
|
|
#include "browser/api/atom_api_dialog.h"
|
|
|
|
#include <string>
|
|
|
|
#include "base/bind.h"
|
|
#include "base/utf_string_conversions.h"
|
|
#include "base/values.h"
|
|
#include "browser/api/atom_api_window.h"
|
|
#include "browser/native_window.h"
|
|
#include "browser/ui/file_dialog.h"
|
|
#include "browser/ui/message_box.h"
|
|
#include "vendor/node/src/node_internals.h"
|
|
|
|
using node::node_isolate;
|
|
|
|
namespace atom {
|
|
|
|
namespace api {
|
|
|
|
namespace {
|
|
|
|
// Trick to overload functions by return value's type.
|
|
struct FromV8Value {
|
|
explicit FromV8Value(v8::Handle<v8::Value> value) : value_(value) {}
|
|
|
|
operator std::string() {
|
|
return *v8::String::Utf8Value(value_);
|
|
}
|
|
|
|
operator int() {
|
|
return value_->IntegerValue();
|
|
}
|
|
|
|
operator base::FilePath() {
|
|
return base::FilePath::FromUTF8Unsafe(FromV8Value(value_));
|
|
}
|
|
|
|
operator atom::NativeWindow*() {
|
|
if (value_->IsObject()) {
|
|
Window* window = Window::Unwrap<Window>(value_->ToObject());
|
|
if (window && window->window())
|
|
return window->window();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
operator v8::Persistent<v8::Function>() {
|
|
return value_->IsFunction() ?
|
|
v8::Persistent<v8::Function>::New(
|
|
node_isolate,
|
|
v8::Handle<v8::Function>::Cast(value_)) :
|
|
v8::Persistent<v8::Function>();
|
|
}
|
|
|
|
v8::Handle<v8::Value> value_;
|
|
};
|
|
|
|
v8::Handle<v8::Value> ToV8Value(const base::FilePath& path) {
|
|
std::string path_string(path.AsUTF8Unsafe());
|
|
return v8::String::New(path_string.data(), path_string.size());
|
|
}
|
|
|
|
v8::Handle<v8::Value> ToV8Value(void* whatever) {
|
|
return v8::Undefined();
|
|
}
|
|
|
|
v8::Handle<v8::Value> ToV8Value(int code) {
|
|
return v8::Integer::New(code);
|
|
}
|
|
|
|
v8::Handle<v8::Value> ToV8Value(const std::vector<base::FilePath>& paths) {
|
|
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]));
|
|
return result;
|
|
}
|
|
|
|
template<typename T>
|
|
void CallV8Function(v8::Persistent<v8::Function> callback, T arg) {
|
|
DCHECK(!callback.IsEmpty());
|
|
|
|
v8::HandleScope scope;
|
|
v8::Handle<v8::Value> value = ToV8Value(arg);
|
|
callback->Call(callback, 1, &value);
|
|
callback.Dispose(node_isolate);
|
|
}
|
|
|
|
template<typename T>
|
|
void CallV8Function2(v8::Persistent<v8::Function> callback,
|
|
bool result,
|
|
T arg) {
|
|
if (result)
|
|
return CallV8Function<T>(callback, arg);
|
|
else
|
|
return CallV8Function<void*>(callback, NULL);
|
|
}
|
|
|
|
void Initialize(v8::Handle<v8::Object> target) {
|
|
v8::HandleScope scope;
|
|
|
|
NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
|
|
NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
|
|
NODE_SET_METHOD(target, "showSaveDialog", ShowSaveDialog);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args) {
|
|
v8::HandleScope scope;
|
|
|
|
if (!args[0]->IsNumber() || // type
|
|
!args[1]->IsArray() || // buttons
|
|
!args[2]->IsString() || // title
|
|
!args[3]->IsString() || // message
|
|
!args[4]->IsString()) // detail
|
|
return node::ThrowTypeError("Bad argument");
|
|
|
|
NativeWindow* native_window = FromV8Value(args[5]);
|
|
v8::Persistent<v8::Function> callback = FromV8Value(args[6]);
|
|
|
|
MessageBoxType type = (MessageBoxType)(args[0]->IntegerValue());
|
|
|
|
std::vector<std::string> buttons;
|
|
v8::Handle<v8::Array> v8_buttons = v8::Handle<v8::Array>::Cast(args[1]);
|
|
for (uint32_t i = 0; i < v8_buttons->Length(); ++i)
|
|
buttons.push_back(FromV8Value(v8_buttons->Get(i)));
|
|
|
|
std::string title = FromV8Value(args[2]);
|
|
std::string message = FromV8Value(args[3]);
|
|
std::string detail = FromV8Value(args[4]);
|
|
|
|
if (callback.IsEmpty()) {
|
|
int chosen = atom::ShowMessageBox(
|
|
native_window, type, buttons, title, message, detail);
|
|
return scope.Close(v8::Integer::New(chosen));
|
|
} else {
|
|
atom::ShowMessageBox(
|
|
native_window,
|
|
type,
|
|
buttons,
|
|
title,
|
|
message,
|
|
detail,
|
|
base::Bind(&CallV8Function<int>, callback));
|
|
return v8::Undefined();
|
|
}
|
|
}
|
|
|
|
v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args) {
|
|
v8::HandleScope scope;
|
|
|
|
if (!args[0]->IsString() || // title
|
|
!args[1]->IsString() || // default_path
|
|
!args[2]->IsNumber()) // properties
|
|
return node::ThrowTypeError("Bad argument");
|
|
|
|
NativeWindow* native_window = FromV8Value(args[3]);
|
|
v8::Persistent<v8::Function> callback = FromV8Value(args[4]);
|
|
|
|
std::string title = FromV8Value(args[0]);
|
|
base::FilePath default_path = FromV8Value(args[1]);
|
|
int properties = FromV8Value(args[2]);
|
|
|
|
if (callback.IsEmpty()) {
|
|
std::vector<base::FilePath> paths;
|
|
if (!file_dialog::ShowOpenDialog(native_window,
|
|
title,
|
|
default_path,
|
|
properties,
|
|
&paths))
|
|
return v8::Undefined();
|
|
|
|
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]));
|
|
|
|
return scope.Close(result);
|
|
} else {
|
|
file_dialog::ShowOpenDialog(
|
|
native_window,
|
|
title,
|
|
default_path,
|
|
properties,
|
|
base::Bind(&CallV8Function2<const std::vector<base::FilePath>&>,
|
|
callback));
|
|
return v8::Undefined();
|
|
}
|
|
}
|
|
|
|
v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments &args) {
|
|
v8::HandleScope scope;
|
|
|
|
if (!args[0]->IsString() || // title
|
|
!args[1]->IsString()) // default_path
|
|
return node::ThrowTypeError("Bad argument");
|
|
|
|
NativeWindow* native_window = FromV8Value(args[2]);
|
|
v8::Persistent<v8::Function> callback = FromV8Value(args[3]);
|
|
|
|
std::string title = FromV8Value(args[0]);
|
|
base::FilePath default_path = FromV8Value(args[1]);
|
|
|
|
if (callback.IsEmpty()) {
|
|
base::FilePath path;
|
|
if (!file_dialog::ShowSaveDialog(native_window,
|
|
title,
|
|
default_path,
|
|
&path))
|
|
return v8::Undefined();
|
|
|
|
return scope.Close(ToV8Value(path));
|
|
} else {
|
|
file_dialog::ShowSaveDialog(
|
|
native_window,
|
|
title,
|
|
default_path,
|
|
base::Bind(&CallV8Function2<const base::FilePath&>, callback));
|
|
return v8::Undefined();
|
|
}
|
|
}
|
|
|
|
} // namespace api
|
|
|
|
} // namespace atom
|
|
|
|
NODE_MODULE(atom_browser_dialog, atom::api::Initialize)
|