// Extracts a C string from a V8 Utf8Value.
const char* ToCString(const v8::String::Utf8Value& value) {
- return *value ? *value : "<string conversion failed>";
+ return *value ? *value : "<string conversion failed>";
}
// Slight modification to an original function found in the V8 sample shell.cc.
void reportException(Isolate* isolate, TryCatch* try_catch) {
- HandleScope handle_scope(isolate);
- String::Utf8Value exception(try_catch->Exception());
- const char* exception_string = ToCString(exception);
- Handle<Message> message = try_catch->Message();
- if (message.IsEmpty()) {
- // V8 didn't provide any extra information about this error; just
- // print the exception.
- fprintf(stderr, "%s\n", exception_string);
- } else {
- // Print (filename):(line number): (message).
- String::Utf8Value filename(message->GetScriptResourceName());
- const char* filename_string = ToCString(filename);
- int linenum = message->GetLineNumber();
- fprintf(stderr, "%s:%i: %s\n", filename_string, linenum, exception_string);
- // Print line of source code.
- String::Utf8Value sourceline(message->GetSourceLine());
- const char* sourceline_string = ToCString(sourceline);
- fprintf(stderr, "%s\n", sourceline_string);
- // Print wavy underline.
- int start = message->GetStartColumn();
- for (int i = 0; i < start; i++) {
- fprintf(stderr, " ");
+ HandleScope handleScope(isolate);
+ String::Utf8Value exception(try_catch->Exception());
+ const char* exception_string = ToCString(exception);
+ Handle<Message> message = try_catch->Message();
+ if (message.IsEmpty()) {
+ // V8 didn't provide any extra information about this error; just
+ // print the exception.
+ fprintf(stderr, "%s\n", exception_string);
+ } else {
+ // Print (filename):(line number): (message).
+ String::Utf8Value filename(message->GetScriptResourceName());
+ const char* filename_string = ToCString(filename);
+ int linenum = message->GetLineNumber();
+ fprintf(stderr,
+ "%s:%i: %s\n", filename_string, linenum, exception_string);
+ // Print line of source code.
+ String::Utf8Value sourceline(message->GetSourceLine());
+ const char* sourceline_string = ToCString(sourceline);
+ fprintf(stderr, "%s\n", sourceline_string);
+ // Print wavy underline.
+ int start = message->GetStartColumn();
+ for (int i = 0; i < start; i++) {
+ fprintf(stderr, " ");
+ }
+ int end = message->GetEndColumn();
+ for (int i = start; i < end; i++) {
+ fprintf(stderr, "^");
+ }
+ fprintf(stderr, "\n");
+ String::Utf8Value stack_trace(try_catch->StackTrace());
+ if (stack_trace.length() > 0) {
+ const char* stack_trace_string = ToCString(stack_trace);
+ fprintf(stderr, "%s\n", stack_trace_string);
+ }
}
- int end = message->GetEndColumn();
- for (int i = start; i < end; i++) {
- fprintf(stderr, "^");
- }
- fprintf(stderr, "\n");
- String::Utf8Value stack_trace(try_catch->StackTrace());
- if (stack_trace.length() > 0) {
- const char* stack_trace_string = ToCString(stack_trace);
- fprintf(stderr, "%s\n", stack_trace_string);
- }
- }
}
-SkV8ExampleWindow::SkV8ExampleWindow(void* hwnd,
- Isolate* isolate,
- Handle<Context> context,
- Handle<Script> script)
+SkV8ExampleWindow::SkV8ExampleWindow(void* hwnd, JsCanvas* canvas)
: INHERITED(hwnd)
- , fIsolate(isolate)
+ , fJsCanvas(canvas)
{
- // Convert the Handle<> objects into Persistent<> objects using Reset().
- fContext.Reset(isolate, context);
- fScript.Reset(isolate, script);
-
fRotationAngle = SkIntToScalar(0);
this->setConfig(SkBitmap::kARGB_8888_Config);
this->setVisibleP(true);
this->setClipToBounds(false);
}
-// Simple global for the Draw function.
-SkCanvas* gCanvas = NULL;
+JsCanvas* JsCanvas::unwrap(Handle<Object> obj) {
+ Handle<External> field = Handle<External>::Cast(obj->GetInternalField(0));
+ void* ptr = field->Value();
+ return static_cast<JsCanvas*>(ptr);
+}
+
+void JsCanvas::inval(const v8::FunctionCallbackInfo<Value>& args) {
+ unwrap(args.This())->fWindow->inval(NULL);
+}
+
+void JsCanvas::drawRect(const v8::FunctionCallbackInfo<Value>& args) {
+ SkCanvas* canvas = unwrap(args.This())->fCanvas;
+
+ canvas->drawColor(SK_ColorWHITE);
+
+ // Draw a rectangle with red paint.
+ SkPaint paint;
+ paint.setColor(SK_ColorRED);
+ SkRect rect = {
+ SkIntToScalar(10), SkIntToScalar(10),
+ SkIntToScalar(128), SkIntToScalar(128)
+ };
+ canvas->drawRect(rect, paint);
+}
+
+Persistent<ObjectTemplate> JsCanvas::fCanvasTemplate;
+
+Handle<ObjectTemplate> JsCanvas::makeCanvasTemplate() {
+ EscapableHandleScope handleScope(fIsolate);
+
+ Local<ObjectTemplate> result = ObjectTemplate::New();
+
+ // Add a field to store the pointer to a JsCanvas instance.
+ result->SetInternalFieldCount(1);
+
+ // Add accessors for each of the fields of the canvas object.
+ result->Set(
+ String::NewFromUtf8(
+ fIsolate, "drawRect", String::kInternalizedString),
+ FunctionTemplate::New(drawRect));
+ result->Set(
+ String::NewFromUtf8(
+ fIsolate, "inval", String::kInternalizedString),
+ FunctionTemplate::New(inval));
+
+ // Return the result through the current handle scope.
+ return handleScope.Escape(result);
+}
+
+
+// Wraps 'this' in a Javascript object.
+Handle<Object> JsCanvas::wrap() {
+ // Handle scope for temporary handles.
+ EscapableHandleScope handleScope(fIsolate);
+
+ // Fetch the template for creating JavaScript JsCanvas wrappers.
+ // It only has to be created once, which we do on demand.
+ if (fCanvasTemplate.IsEmpty()) {
+ Handle<ObjectTemplate> raw_template = this->makeCanvasTemplate();
+ fCanvasTemplate.Reset(fIsolate, raw_template);
+ }
+ Handle<ObjectTemplate> templ =
+ Local<ObjectTemplate>::New(fIsolate, fCanvasTemplate);
+ // Create an empty JsCanvas wrapper.
+ Local<Object> result = templ->NewInstance();
-// Draw is called from within V8 when the Javascript function draw() is called.
-void Draw(const v8::FunctionCallbackInfo<v8::Value>& args) {
- if (NULL == gCanvas) {
- printf("Can't Draw Now.\n");
- return;
- }
+ // Wrap the raw C++ pointer in an External so it can be referenced
+ // from within JavaScript.
+ Handle<External> canvasPtr = External::New(fIsolate, this);
- gCanvas->drawColor(SK_ColorWHITE);
- SkPaint paint;
- paint.setColor(SK_ColorRED);
+ // Store the canvas pointer in the JavaScript wrapper.
+ result->SetInternalField(0, canvasPtr);
- // Draw a rectangle with blue paint
- SkRect rect = {
- SkIntToScalar(10), SkIntToScalar(10),
- SkIntToScalar(128), SkIntToScalar(128)
- };
- gCanvas->drawRect(rect, paint);
+ // Return the result through the current handle scope. Since each
+ // of these handles will go away when the handle scope is deleted
+ // we need to call Close to let one, the result, escape into the
+ // outer handle scope.
+ return handleScope.Escape(result);
+}
+
+void JsCanvas::onDraw(SkCanvas* canvas, SkOSWindow* window) {
+ // Record canvas and window in this.
+ fCanvas = canvas;
+ fWindow = window;
+
+ // Create a handle scope to keep the temporary object references.
+ HandleScope handleScope(fIsolate);
+
+ // Create a local context from our global context.
+ Local<Context> context = Local<Context>::New(fIsolate, fContext);
+
+ // Enter the context so all the remaining operations take place there.
+ Context::Scope contextScope(context);
+
+ // Wrap the C++ this pointer in a JavaScript wrapper.
+ Handle<Object> canvasObj = this->wrap();
+
+ // Set up an exception handler before calling the Process function.
+ TryCatch tryCatch;
+
+ // Invoke the process function, giving the global object as 'this'
+ // and one argument, this JsCanvas.
+ const int argc = 1;
+ Handle<Value> argv[argc] = { canvasObj };
+ Local<Function> onDraw =
+ Local<Function>::New(fIsolate, fOnDraw);
+ Handle<Value> result = onDraw->Call(context->Global(), argc, argv);
+
+ // Handle any exceptions or output.
+ if (result.IsEmpty()) {
+ SkASSERT(tryCatch.HasCaught());
+ // Print errors that happened during execution.
+ reportException(fIsolate, &tryCatch);
+ } else {
+ SkASSERT(!tryCatch.HasCaught());
+ if (!result->IsUndefined()) {
+ // If all went well and the result wasn't undefined then print
+ // the returned value.
+ String::Utf8Value str(result);
+ const char* cstr = ToCString(str);
+ printf("%s\n", cstr);
+ }
+ }
}
void SkV8ExampleWindow::onDraw(SkCanvas* canvas) {
- printf("Draw\n");
-
- gCanvas = canvas;
- canvas->save();
- fRotationAngle += SkDoubleToScalar(0.2);
- if (fRotationAngle > SkDoubleToScalar(360.0)) {
- fRotationAngle -= SkDoubleToScalar(360.0);
- }
- canvas->rotate(fRotationAngle);
-
- // Create a Handle scope for temporary references.
- HandleScope handle_scope(fIsolate);
-
- // Create a local context from our persistent context.
- Local<Context> context =
- Local<Context>::New(fIsolate, fContext);
-
- // Enter the context so all operations take place within it.
- Context::Scope context_scope(context);
-
- TryCatch try_catch;
-
- // Create a local script from our persistent script.
- Local<Script> script =
- Local<Script>::New(fIsolate, fScript);
-
- // Run the script.
- Handle<Value> result = script->Run();
-
- if (result.IsEmpty()) {
- SkASSERT(try_catch.HasCaught());
- // Print errors that happened during execution.
- reportException(fIsolate, &try_catch);
- } else {
- SkASSERT(!try_catch.HasCaught());
- if (!result->IsUndefined()) {
- // If all went well and the result wasn't undefined then print
- // the returned value.
- String::Utf8Value str(result);
- const char* cstr = ToCString(str);
- printf("%s\n", cstr);
+
+ canvas->save();
+
+ fRotationAngle += SkDoubleToScalar(0.2);
+ if (fRotationAngle > SkDoubleToScalar(360.0)) {
+ fRotationAngle -= SkDoubleToScalar(360.0);
}
- }
- canvas->restore();
+ canvas->rotate(fRotationAngle);
- // Trigger an invalidation which should trigger another redraw to simulate
- // animation.
- this->inval(NULL);
+ // Now jump into JS and call the onDraw(canvas) method defined there.
+ fJsCanvas->onDraw(canvas, this);
- INHERITED::onDraw(canvas);
+ canvas->restore();
+
+ INHERITED::onDraw(canvas);
}
Handle<Context> createRootContext(Isolate* isolate) {
// Create a template for the global object.
Handle<ObjectTemplate> global = ObjectTemplate::New();
- // Bind the global 'draw' function to the C++ Draw callback.
- global->Set(String::NewFromUtf8(isolate, "draw"),
- FunctionTemplate::New(Draw));
+
+ // This is where we would inject any globals into the root Context
+ // using global->Set(...)
return Context::New(isolate, NULL, global);
}
-SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
- printf("Started\n");
- // Get the default Isolate created at startup.
- Isolate* isolate = Isolate::GetCurrent();
- printf("Isolate\n");
+// Parse and run script. Then fetch out the onDraw function from the global
+// object.
+bool JsCanvas::initialize(const char script[]) {
+
+ // Create a stack-allocated handle scope.
+ HandleScope handleScope(fIsolate);
+
+ printf("Before create context\n");
- // Create a stack-allocated handle scope.
- HandleScope handle_scope(isolate);
+ // Create a new context.
+ Handle<Context> context = createRootContext(fIsolate);
- printf("Before create context\n");
- // Create a new context.
- //
- Handle<Context> context = createRootContext(isolate);
+ // Enter the scope so all operations take place in the scope.
+ Context::Scope contextScope(context);
- // Enter the scope so all operations take place in the scope.
- Context::Scope context_scope(context);
+ v8::TryCatch try_catch;
- v8::TryCatch try_catch;
+ // Compile the source code.
+ Handle<String> source = String::NewFromUtf8(fIsolate, script);
+ printf("Before Compile\n");
+ Handle<Script> compiled_script = Script::Compile(source);
+ printf("After Compile\n");
- // Compile the source code.
- Handle<String> source = String::NewFromUtf8(isolate, "draw();");
- printf("Before Compile\n");
- Handle<Script> script = Script::Compile(source);
- printf("After Compile\n");
+ if (compiled_script.IsEmpty()) {
+ // Print errors that happened during compilation.
+ reportException(fIsolate, &try_catch);
+ return false;
+ }
+ printf("After Exception.\n");
+
+ // Try running it now to create the onDraw function.
+ Handle<Value> result = compiled_script->Run();
+
+ // Handle any exceptions or output.
+ if (result.IsEmpty()) {
+ SkASSERT(try_catch.HasCaught());
+ // Print errors that happened during execution.
+ reportException(fIsolate, &try_catch);
+ return false;
+ } else {
+ SkASSERT(!try_catch.HasCaught());
+ if (!result->IsUndefined()) {
+ // If all went well and the result wasn't undefined then print
+ // the returned value.
+ String::Utf8Value str(result);
+ const char* cstr = ToCString(str);
+ printf("%s\n", cstr);
+ return false;
+ }
+ }
+
+ Handle<String> fn_name = String::NewFromUtf8(fIsolate, "onDraw");
+ Handle<Value> fn_val = context->Global()->Get(fn_name);
+
+ if (!fn_val->IsFunction()) {
+ return false;
+ }
- // Try running it now. It won't have a valid context, but shouldn't fail.
- script->Run();
+ // It is a function; cast it to a Function.
+ Handle<Function> fn_fun = Handle<Function>::Cast(fn_val);
- if (script.IsEmpty()) {
- // Print errors that happened during compilation.
- reportException(isolate, &try_catch);
- exit(1);
- }
- printf("After Exception.\n");
+ // Store the function in a Persistent handle, since we also want that to
+ // remain after this call returns.
+ fOnDraw.Reset(fIsolate, fn_fun);
+
+ // Also make the context persistent.
+ fContext.Reset(fIsolate, context);
+ return true;
+}
+
+SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
+ printf("Started\n");
+
+ // Get the default Isolate created at startup.
+ Isolate* isolate = Isolate::GetCurrent();
+
+ JsCanvas* jsCanvas = new JsCanvas(isolate);
+ const char* script = "function onDraw(canvas){"
+ "canvas.drawRect();"
+ "canvas.inval();"
+ "};";
+ if (!jsCanvas->initialize(script)) {
+ printf("Failed to initialize.\n");
+ exit(1);
+ }
- // SkV8ExampleWindow will make persistent handles to hold the context and script.
- return new SkV8ExampleWindow(hwnd, isolate, context, script);
+ return new SkV8ExampleWindow(hwnd, jsCanvas);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff