← Back to branch summary

~davidc3/+junk/js-scopes-misc

« back to all changes in this revision

Viewing changes to src/bindings/src/addon.cc

  • Committer: Alexandre Abreu
  • Date: 2015-07-20 21:05:06 UTC
  • mfrom: (12.1.3 latest)
  • Revision ID: alexandre.abreu@canonical.com-20150720210506-sb68o2lasi8gqu12
Fix launcher scope_id; updated JS api; start porting to better v8cpp bindings; fix scope_id

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/bindings/src/addon.cc
41
41
#include "preview-reply.h"
42
42
#include "preview-widget.h"
43
43
 
44
 
v8::Handle<v8::Object> new_scope(
45
 
      v8::FunctionCallbackInfo<v8::Value> const& args) {
46
 
  if (args.Length() != 2) {
47
 
    throw std::runtime_error("Invalid number of arguments");
48
 
  }
49
 
  if (!args[0]->IsString() || !args[1]->IsString()) {
50
 
    throw std::runtime_error("Invalid arguments types");
51
 
  }
52
 
 
53
 
  std::string scope_id =
54
 
    *(v8::String::Utf8Value(args[0]->ToString()));
55
 
 
56
 
  if (!boost::ends_with(scope_id, ".ini")) {
57
 
    throw std::runtime_error("Invalid scope id (ini file)");
58
 
  }
59
 
 
60
 
  if (!boost::filesystem::path(scope_id).is_absolute()) {
61
 
    auto p =
62
 
      boost::filesystem::current_path() /= boost::filesystem::path(scope_id);
63
 
 
64
 
    if (!boost::filesystem::exists(p)) {
65
 
      throw std::runtime_error("Invalid scope id (file not found)");
66
 
    }
67
 
 
68
 
    scope_id = p.native();
69
 
  }
70
 
 
71
 
  std::string config_file =
72
 
    *(v8::String::Utf8Value(args[1]->ToString()));
73
 
 
74
 
  JsScope* scope =
75
 
    new JsScope(scope_id, config_file);
76
 
 
77
 
  return v8cpp::export_object<JsScope>(
78
 
      v8::Isolate::GetCurrent(), scope);
 
44
// TODO static
 
45
JavascriptScopeRuntime* new_scope(const std::string& runtime_config) {
 
46
  return new JavascriptScopeRuntime(runtime_config);
79
47
}
80
48
 
81
49
v8::Handle<v8::Object> new_search_query(
85
53
  }
86
54
 
87
55
  CannedQuery *c =
88
 
    v8cpp::import_object<CannedQuery>(
 
56
    v8cpp::from_v8<CannedQuery*>(
89
57
        v8::Isolate::GetCurrent(),
90
58
        args[0]->ToObject());
91
59
 
92
60
  SearchMetaData *s =
93
 
    v8cpp::import_object<SearchMetaData>(
 
61
    v8cpp::from_v8<SearchMetaData*>(
94
62
        v8::Isolate::GetCurrent(),
95
63
        args[1]->ToObject());
96
64
 
114
82
        run_callback,
115
83
        cancelled_callback);
116
84
 
117
 
  return v8cpp::export_object<SearchQuery>(v8::Isolate::GetCurrent(), sq);
 
85
  return v8cpp::to_v8(v8::Isolate::GetCurrent(), sq);
118
86
}
119
87
 
120
88
v8::Handle<v8::Object> new_category_renderer(
130
98
 
131
99
  CategoryRenderer* category_renderer = new CategoryRenderer(json_text);
132
100
 
133
 
  return v8cpp::export_object<CategoryRenderer>(
134
 
      v8::Isolate::GetCurrent(), category_renderer);
 
101
  return v8cpp::to_v8(v8::Isolate::GetCurrent(), category_renderer);
135
102
}
136
103
 
137
104
v8::Handle<v8::Object> new_preview_query(v8::FunctionCallbackInfo<v8::Value> const& args) {
139
106
    throw std::runtime_error("Invalid number of arguments");
140
107
  }
141
108
 
142
 
  Result *r = v8cpp::import_object<Result>(v8::Isolate::GetCurrent(), args[0]->ToObject());
 
109
  Result *r =
 
110
    v8cpp::from_v8<Result*>(v8::Isolate::GetCurrent(), args[0]->ToObject());
143
111
 
144
112
  ActionMetaData *a =
145
 
    v8cpp::import_object<ActionMetaData>(v8::Isolate::GetCurrent(), args[1]->ToObject());
 
113
    v8cpp::from_v8<ActionMetaData*>(v8::Isolate::GetCurrent(), args[1]->ToObject());
146
114
 
147
115
  if (!r || !a) {
148
116
    throw std::runtime_error("Invalid arguments types");
168
136
        a->get_action_metadata(),
169
137
        run_callback,
170
138
        cancelled_callback);
171
 
  return v8cpp::export_object<PreviewQuery>(v8::Isolate::GetCurrent(), pq);
 
139
  return v8cpp::to_v8(v8::Isolate::GetCurrent(), pq);
172
140
}
173
141
 
174
142
v8::Handle<v8::Object> new_preview_widget(v8::FunctionCallbackInfo<v8::Value> const& args) {
189
157
    PreviewWidget* preview_widget =
190
158
      new PreviewWidget(id, widget_type);
191
159
 
192
 
    return v8cpp::export_object<PreviewWidget>(
193
 
        v8::Isolate::GetCurrent(), preview_widget);
 
160
    return v8cpp::to_v8(v8::Isolate::GetCurrent(), preview_widget);
194
161
  }
195
162
 
196
163
  if (!args[0]->IsString()) {
203
170
  PreviewWidget* preview_widget =
204
171
    new PreviewWidget(definition);
205
172
  
206
 
  return v8cpp::export_object<PreviewWidget>(
207
 
        v8::Isolate::GetCurrent(), preview_widget);
 
173
  return v8cpp::to_v8(v8::Isolate::GetCurrent(), preview_widget);
208
174
}
209
175
 
210
176
v8::Handle<v8::Object> new_categorised_result(
214
180
  }
215
181
 
216
182
  Category *c =
217
 
    v8cpp::import_object<Category>(v8::Isolate::GetCurrent(),
218
 
                                   args[0]->ToObject());
 
183
    v8cpp::from_v8<Category*>(v8::Isolate::GetCurrent(),
 
184
                             args[0]->ToObject());
219
185
 
220
186
  if (!c) {
221
187
    throw std::runtime_error("Invalid arguments types");
223
189
 
224
190
  CategorisedResult *cr = new CategorisedResult(c);
225
191
 
226
 
  return v8cpp::export_object<CategorisedResult>(v8::Isolate::GetCurrent(), cr);
 
192
  return v8cpp::to_v8(v8::Isolate::GetCurrent(), cr);
227
193
}
228
194
 
229
195
void InitAll(v8::Handle<v8::Object> exports)
230
196
{
231
197
    v8::Isolate* isolate = v8::Isolate::GetCurrent();
232
198
 
233
 
    v8cpp::Class<JsScope> js_scope(isolate);
 
199
    v8cpp::Class<JavascriptScopeRuntime> js_scope(isolate);
234
200
    js_scope
235
 
      .add_method("scope_base", &JsScope::scope_base)
236
 
      .add_method("run", &JsScope::run);
 
201
      .add_method("scope_base", &JavascriptScopeRuntime::scope_base)
 
202
      .add_method("scope_config", &JavascriptScopeRuntime::scope_config)
 
203
      .add_method("run", &JavascriptScopeRuntime::run);
237
204
 
238
205
    v8cpp::Class<ScopeBase> scope_base(isolate);
239
206
    scope_base