From 5d49d819924da76f96f22845210abe89a7ade187 Mon Sep 17 00:00:00 2001 From: Nick Holland Date: Tue, 20 Jan 2015 16:02:00 +0000 Subject: [PATCH] JavaScript support for DALi Configure with --enable-javascript to use Requires v8 to build (v3.25.19) git clone git://github.com/v8/v8.git cd v8 git checkout 5475d473f7fa6f33296276e7b25fc1fe955ab166 Change-Id: Ic22273ab0875e6e21186261fe88a2ac57af162ae --- build/tizen/Makefile.am | 9 +- build/tizen/configure.ac | 17 + build/tizen/dali-toolkit/Makefile.am | 4 + build/tizen/plugins/Makefile.am | 61 + dali-toolkit/dali-toolkit.h | 6 +- dali-toolkit/internal/file.list | 5 +- dali-toolkit/internal/scripting/script-impl.cpp | 81 ++ dali-toolkit/internal/scripting/script-impl.h | 104 ++ .../internal/scripting/script-plugin-proxy.cpp | 153 +++ .../internal/scripting/script-plugin-proxy.h | 106 ++ dali-toolkit/public-api/file.list | 5 + dali-toolkit/public-api/scripting/script-plugin.h | 85 ++ dali-toolkit/public-api/scripting/script.cpp | 57 + dali-toolkit/public-api/scripting/script.h | 91 ++ docs/content/images/screenshot.png | Bin 244509 -> 469534 bytes .../multi-touch-guide.md | 148 +++ plugins/dali-script-v8/.gitignore | 1 + plugins/dali-script-v8/docs/.gitignore | 6 + plugins/dali-script-v8/docs/README.txt | 11 + plugins/dali-script-v8/docs/content/actor.js | 647 +++++++++++ plugins/dali-script-v8/docs/content/animation.js | 257 +++++ .../dali-script-v8/docs/content/camera-actor.js | 51 + plugins/dali-script-v8/docs/content/constants.js | 173 +++ plugins/dali-script-v8/docs/content/dali.js | 60 + plugins/dali-script-v8/docs/content/helpers.js | 5 + plugins/dali-script-v8/docs/content/image-actor.js | 64 ++ plugins/dali-script-v8/docs/content/image.js | 75 ++ .../docs/content/keyboard-focus-manager.js | 66 ++ plugins/dali-script-v8/docs/content/layer-actor.js | 45 + .../dali-script-v8/docs/content/module-loader.js | 8 + .../docs/content/pan-gesture-detector.js | 41 + .../dali-script-v8/docs/content/path-animation.js | 46 + plugins/dali-script-v8/docs/content/render-task.js | 87 ++ .../docs/content/renderable-actor.js | 17 + .../dali-script-v8/docs/content/resource-image.js | 43 + .../dali-script-v8/docs/content/shader-effect.js | 259 +++++ plugins/dali-script-v8/docs/content/stage.js | 67 ++ plugins/dali-script-v8/docs/content/text-actor.js | 79 ++ .../dali-script-v8/docs/content/texture-atlases.js | 149 +++ .../docs/content/texture-compression.js | 58 + .../docs/dali-theme/assets/css/external-small.png | Bin 0 -> 491 bytes .../docs/dali-theme/assets/css/logo.png | Bin 0 -> 11599 bytes .../docs/dali-theme/assets/css/main.css | 783 +++++++++++++ .../docs/dali-theme/assets/favicon.png | Bin 0 -> 740 bytes .../assets/img/example-javascript-code.png | Bin 0 -> 153720 bytes .../docs/dali-theme/assets/img/focus-manager.png | Bin 0 -> 209774 bytes .../assets/img/fragment-shader-color.png | Bin 0 -> 194229 bytes .../assets/img/fragment-shader-reveal.png | Bin 0 -> 164631 bytes .../dali-theme/assets/img/keyframe-animation.png | Bin 0 -> 7634 bytes .../docs/dali-theme/assets/img/path.png | Bin 0 -> 58237 bytes .../dali-theme/assets/img/shader-animation.png | Bin 0 -> 178102 bytes .../dali-theme/assets/img/shader-grid-hint.png | Bin 0 -> 180570 bytes .../docs/dali-theme/assets/img/shared | 1 + .../docs/dali-theme/assets/img/spinner.gif | Bin 0 -> 2685 bytes .../docs/dali-theme/assets/img/stage.png | Bin 0 -> 8346 bytes .../docs/dali-theme/assets/img/vertex-shader.png | Bin 0 -> 223855 bytes .../docs/dali-theme/assets/index.html | 10 + .../docs/dali-theme/assets/js/api-filter.js | 52 + .../docs/dali-theme/assets/js/api-list.js | 251 +++++ .../docs/dali-theme/assets/js/api-search.js | 98 ++ .../docs/dali-theme/assets/js/apidocs.js | 370 ++++++ .../docs/dali-theme/assets/js/yui-prettify.js | 17 + .../dali-theme/assets/vendor/prettify/CHANGES.html | 130 +++ .../docs/dali-theme/assets/vendor/prettify/COPYING | 202 ++++ .../assets/vendor/prettify/prettify-min.css | 1 + .../assets/vendor/prettify/prettify-min.js | 1 + .../docs/dali-theme/layouts/main.handlebars | 55 + .../docs/dali-theme/layouts/xhr.handlebars | 7 + .../docs/dali-theme/partials/attrs.handlebars | 141 +++ .../docs/dali-theme/partials/classes.handlebars | 203 ++++ .../docs/dali-theme/partials/events.handlebars | 137 +++ .../docs/dali-theme/partials/files.handlebars | 7 + .../docs/dali-theme/partials/index.handlebars | 21 + .../docs/dali-theme/partials/method.handlebars | 212 ++++ .../docs/dali-theme/partials/module.handlebars | 92 ++ .../docs/dali-theme/partials/options.handlebars | 23 + .../docs/dali-theme/partials/props.handlebars | 119 ++ .../docs/dali-theme/partials/sidebar.handlebars | 27 + plugins/dali-script-v8/docs/dali-theme/theme.json | 4 + plugins/dali-script-v8/docs/gmon.out | Bin 0 -> 1963 bytes plugins/dali-script-v8/docs/yuidoc.json | 13 + plugins/dali-script-v8/file.list | 57 + plugins/dali-script-v8/src/actors/actor-api.cpp | 715 ++++++++++++ plugins/dali-script-v8/src/actors/actor-api.h | 85 ++ .../dali-script-v8/src/actors/actor-wrapper.cpp | 528 +++++++++ plugins/dali-script-v8/src/actors/actor-wrapper.h | 131 +++ .../dali-script-v8/src/actors/camera-actor-api.cpp | 139 +++ .../dali-script-v8/src/actors/camera-actor-api.h | 51 + .../dali-script-v8/src/actors/image-actor-api.cpp | 211 ++++ .../dali-script-v8/src/actors/image-actor-api.h | 54 + plugins/dali-script-v8/src/actors/layer-api.cpp | 299 +++++ plugins/dali-script-v8/src/actors/layer-api.h | 60 + .../dali-script-v8/src/actors/mesh-actor-api.cpp | 97 ++ plugins/dali-script-v8/src/actors/mesh-actor-api.h | 52 + .../src/actors/renderable-actor-api.cpp | 546 +++++++++ .../src/actors/renderable-actor-api.h | 62 ++ .../dali-script-v8/src/actors/text-actor-api.cpp | 164 +++ plugins/dali-script-v8/src/actors/text-actor-api.h | 43 + .../dali-script-v8/src/animation/animation-api.cpp | 1174 ++++++++++++++++++++ .../dali-script-v8/src/animation/animation-api.h | 84 ++ .../src/animation/animation-wrapper.cpp | 172 +++ .../src/animation/animation-wrapper.h | 82 ++ plugins/dali-script-v8/src/animation/path-api.cpp | 175 +++ plugins/dali-script-v8/src/animation/path-api.h | 50 + .../dali-script-v8/src/animation/path-wrapper.cpp | 121 ++ .../dali-script-v8/src/animation/path-wrapper.h | 83 ++ .../src/constants/constants-wrapper.cpp | 292 +++++ .../src/constants/constants-wrapper.h | 39 + plugins/dali-script-v8/src/dali-script-v8.cpp | 74 ++ plugins/dali-script-v8/src/dali-script-v8.h | 72 ++ plugins/dali-script-v8/src/dali-wrapper.cpp | 268 +++++ plugins/dali-script-v8/src/dali-wrapper.h | 161 +++ .../src/events/event-object-generator.cpp | 399 +++++++ .../src/events/event-object-generator.h | 59 + .../src/events/pan-gesture-detector-api.cpp | 122 ++ .../src/events/pan-gesture-detector-api.h | 50 + .../src/events/pan-gesture-detector-wrapper.cpp | 119 ++ .../src/events/pan-gesture-detector-wrapper.h | 82 ++ .../src/garbage-collector/garbage-collector.cpp | 64 ++ .../src/garbage-collector/garbage-collector.h | 82 ++ .../dali-script-v8/src/image/buffer-image-api.cpp | 253 +++++ .../dali-script-v8/src/image/buffer-image-api.h | 62 ++ .../src/image/frame-buffer-image-api.cpp | 116 ++ .../src/image/frame-buffer-image-api.h | 47 + plugins/dali-script-v8/src/image/image-api.cpp | 104 ++ plugins/dali-script-v8/src/image/image-api.h | 58 + .../src/image/image-attributes-api.cpp | 209 ++++ .../src/image/image-attributes-api.h | 63 ++ .../src/image/image-attributes-wrapper.cpp | 145 +++ .../src/image/image-attributes-wrapper.h | 85 ++ plugins/dali-script-v8/src/image/image-wrapper.cpp | 325 ++++++ plugins/dali-script-v8/src/image/image-wrapper.h | 130 +++ .../dali-script-v8/src/image/native-image-api.cpp | 63 ++ .../dali-script-v8/src/image/native-image-api.h | 47 + .../src/image/nine-patch-image-api.cpp | 174 +++ .../src/image/nine-patch-image-api.h | 58 + .../src/image/resource-image-api.cpp | 217 ++++ .../dali-script-v8/src/image/resource-image-api.h | 60 + .../src/interfaces/garbage-collector-interface.h | 97 ++ .../src/module-loader/module-loader.cpp | 426 +++++++ .../src/module-loader/module-loader.h | 146 +++ .../dali-script-v8/src/module-loader/module.cpp | 54 + plugins/dali-script-v8/src/module-loader/module.h | 85 ++ .../dali-script-v8/src/object/handle-wrapper.cpp | 185 +++ plugins/dali-script-v8/src/object/handle-wrapper.h | 96 ++ .../src/object/property-value-wrapper.cpp | 958 ++++++++++++++++ .../src/object/property-value-wrapper.h | 160 +++ .../src/render-tasks/render-task-api.cpp | 526 +++++++++ .../src/render-tasks/render-task-api.h | 64 ++ .../src/render-tasks/render-task-list-api.cpp | 155 +++ .../src/render-tasks/render-task-list-api.h | 53 + .../src/render-tasks/render-task-list-wrapper.cpp | 138 +++ .../src/render-tasks/render-task-list-wrapper.h | 75 ++ .../src/render-tasks/render-task-wrapper.cpp | 155 +++ .../src/render-tasks/render-task-wrapper.h | 77 ++ .../src/shader-effects/shader-effect-api.cpp | 423 +++++++ .../src/shader-effects/shader-effect-api.h | 57 + .../src/shader-effects/shader-effect-wrapper.cpp | 142 +++ .../src/shader-effects/shader-effect-wrapper.h | 84 ++ plugins/dali-script-v8/src/shared/api-function.h | 54 + .../src/shared/base-wrapped-object.cpp | 136 +++ .../src/shared/base-wrapped-object.h | 185 +++ .../src/shared/object-template-helper.cpp | 81 ++ .../src/shared/object-template-helper.h | 66 ++ .../src/signals/dali-any-javascript-converter.cpp | 205 ++++ .../src/signals/dali-any-javascript-converter.h | 55 + .../src/signals/emit-notification-interface.h | 65 ++ .../dali-script-v8/src/signals/signal-manager.cpp | 760 +++++++++++++ .../dali-script-v8/src/signals/signal-manager.h | 143 +++ plugins/dali-script-v8/src/stage/stage-api.cpp | 266 +++++ plugins/dali-script-v8/src/stage/stage-api.h | 60 + plugins/dali-script-v8/src/stage/stage-wrapper.cpp | 121 ++ plugins/dali-script-v8/src/stage/stage-wrapper.h | 77 ++ plugins/dali-script-v8/src/text/font-api.cpp | 458 ++++++++ plugins/dali-script-v8/src/text/font-api.h | 68 ++ plugins/dali-script-v8/src/text/font-wrapper.cpp | 162 +++ plugins/dali-script-v8/src/text/font-wrapper.h | 78 ++ .../src/toolkit/builder/builder-api.cpp | 474 ++++++++ .../src/toolkit/builder/builder-api.h | 63 ++ .../src/toolkit/builder/builder-wrapper.cpp | 133 +++ .../src/toolkit/builder/builder-wrapper.h | 74 ++ .../focus-manager/keyboard-focus-manager-api.cpp | 305 +++++ .../focus-manager/keyboard-focus-manager-api.h | 62 ++ .../keyboard-focus-manager-wrapper.cpp | 149 +++ .../focus-manager/keyboard-focus-manager-wrapper.h | 83 ++ plugins/dali-script-v8/src/utils/v8-utils.cpp | 1017 +++++++++++++++++ plugins/dali-script-v8/src/utils/v8-utils.h | 373 +++++++ 187 files changed, 25484 insertions(+), 3 deletions(-) create mode 100644 build/tizen/plugins/Makefile.am create mode 100644 dali-toolkit/internal/scripting/script-impl.cpp create mode 100644 dali-toolkit/internal/scripting/script-impl.h create mode 100644 dali-toolkit/internal/scripting/script-plugin-proxy.cpp create mode 100644 dali-toolkit/internal/scripting/script-plugin-proxy.h create mode 100644 dali-toolkit/public-api/scripting/script-plugin.h create mode 100644 dali-toolkit/public-api/scripting/script.cpp create mode 100644 dali-toolkit/public-api/scripting/script.h create mode 100644 docs/content/shared-javascript-and-cpp-documentation/multi-touch-guide.md create mode 100644 plugins/dali-script-v8/.gitignore create mode 100644 plugins/dali-script-v8/docs/.gitignore create mode 100644 plugins/dali-script-v8/docs/README.txt create mode 100644 plugins/dali-script-v8/docs/content/actor.js create mode 100644 plugins/dali-script-v8/docs/content/animation.js create mode 100644 plugins/dali-script-v8/docs/content/camera-actor.js create mode 100644 plugins/dali-script-v8/docs/content/constants.js create mode 100644 plugins/dali-script-v8/docs/content/dali.js create mode 100644 plugins/dali-script-v8/docs/content/helpers.js create mode 100644 plugins/dali-script-v8/docs/content/image-actor.js create mode 100644 plugins/dali-script-v8/docs/content/image.js create mode 100644 plugins/dali-script-v8/docs/content/keyboard-focus-manager.js create mode 100644 plugins/dali-script-v8/docs/content/layer-actor.js create mode 100644 plugins/dali-script-v8/docs/content/module-loader.js create mode 100644 plugins/dali-script-v8/docs/content/pan-gesture-detector.js create mode 100644 plugins/dali-script-v8/docs/content/path-animation.js create mode 100644 plugins/dali-script-v8/docs/content/render-task.js create mode 100644 plugins/dali-script-v8/docs/content/renderable-actor.js create mode 100644 plugins/dali-script-v8/docs/content/resource-image.js create mode 100644 plugins/dali-script-v8/docs/content/shader-effect.js create mode 100644 plugins/dali-script-v8/docs/content/stage.js create mode 100644 plugins/dali-script-v8/docs/content/text-actor.js create mode 100644 plugins/dali-script-v8/docs/content/texture-atlases.js create mode 100644 plugins/dali-script-v8/docs/content/texture-compression.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/css/external-small.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/css/logo.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/css/main.css create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/favicon.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/example-javascript-code.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/focus-manager.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/fragment-shader-color.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/fragment-shader-reveal.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/keyframe-animation.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/path.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/shader-animation.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/shader-grid-hint.png create mode 120000 plugins/dali-script-v8/docs/dali-theme/assets/img/shared create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/spinner.gif create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/stage.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/img/vertex-shader.png create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/index.html create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/js/api-filter.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/js/api-list.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/js/api-search.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/js/apidocs.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/js/yui-prettify.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/CHANGES.html create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/COPYING create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.css create mode 100644 plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.js create mode 100644 plugins/dali-script-v8/docs/dali-theme/layouts/main.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/layouts/xhr.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/attrs.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/classes.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/events.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/files.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/index.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/method.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/module.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/options.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/props.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/partials/sidebar.handlebars create mode 100644 plugins/dali-script-v8/docs/dali-theme/theme.json create mode 100644 plugins/dali-script-v8/docs/gmon.out create mode 100644 plugins/dali-script-v8/docs/yuidoc.json create mode 100644 plugins/dali-script-v8/file.list create mode 100644 plugins/dali-script-v8/src/actors/actor-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/actor-api.h create mode 100644 plugins/dali-script-v8/src/actors/actor-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/actors/actor-wrapper.h create mode 100644 plugins/dali-script-v8/src/actors/camera-actor-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/camera-actor-api.h create mode 100644 plugins/dali-script-v8/src/actors/image-actor-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/image-actor-api.h create mode 100644 plugins/dali-script-v8/src/actors/layer-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/layer-api.h create mode 100644 plugins/dali-script-v8/src/actors/mesh-actor-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/mesh-actor-api.h create mode 100644 plugins/dali-script-v8/src/actors/renderable-actor-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/renderable-actor-api.h create mode 100644 plugins/dali-script-v8/src/actors/text-actor-api.cpp create mode 100644 plugins/dali-script-v8/src/actors/text-actor-api.h create mode 100644 plugins/dali-script-v8/src/animation/animation-api.cpp create mode 100644 plugins/dali-script-v8/src/animation/animation-api.h create mode 100644 plugins/dali-script-v8/src/animation/animation-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/animation/animation-wrapper.h create mode 100644 plugins/dali-script-v8/src/animation/path-api.cpp create mode 100644 plugins/dali-script-v8/src/animation/path-api.h create mode 100644 plugins/dali-script-v8/src/animation/path-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/animation/path-wrapper.h create mode 100644 plugins/dali-script-v8/src/constants/constants-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/constants/constants-wrapper.h create mode 100644 plugins/dali-script-v8/src/dali-script-v8.cpp create mode 100644 plugins/dali-script-v8/src/dali-script-v8.h create mode 100644 plugins/dali-script-v8/src/dali-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/dali-wrapper.h create mode 100644 plugins/dali-script-v8/src/events/event-object-generator.cpp create mode 100644 plugins/dali-script-v8/src/events/event-object-generator.h create mode 100644 plugins/dali-script-v8/src/events/pan-gesture-detector-api.cpp create mode 100644 plugins/dali-script-v8/src/events/pan-gesture-detector-api.h create mode 100644 plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.h create mode 100644 plugins/dali-script-v8/src/garbage-collector/garbage-collector.cpp create mode 100644 plugins/dali-script-v8/src/garbage-collector/garbage-collector.h create mode 100644 plugins/dali-script-v8/src/image/buffer-image-api.cpp create mode 100644 plugins/dali-script-v8/src/image/buffer-image-api.h create mode 100644 plugins/dali-script-v8/src/image/frame-buffer-image-api.cpp create mode 100644 plugins/dali-script-v8/src/image/frame-buffer-image-api.h create mode 100644 plugins/dali-script-v8/src/image/image-api.cpp create mode 100644 plugins/dali-script-v8/src/image/image-api.h create mode 100644 plugins/dali-script-v8/src/image/image-attributes-api.cpp create mode 100644 plugins/dali-script-v8/src/image/image-attributes-api.h create mode 100644 plugins/dali-script-v8/src/image/image-attributes-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/image/image-attributes-wrapper.h create mode 100644 plugins/dali-script-v8/src/image/image-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/image/image-wrapper.h create mode 100644 plugins/dali-script-v8/src/image/native-image-api.cpp create mode 100644 plugins/dali-script-v8/src/image/native-image-api.h create mode 100644 plugins/dali-script-v8/src/image/nine-patch-image-api.cpp create mode 100644 plugins/dali-script-v8/src/image/nine-patch-image-api.h create mode 100644 plugins/dali-script-v8/src/image/resource-image-api.cpp create mode 100644 plugins/dali-script-v8/src/image/resource-image-api.h create mode 100644 plugins/dali-script-v8/src/interfaces/garbage-collector-interface.h create mode 100644 plugins/dali-script-v8/src/module-loader/module-loader.cpp create mode 100644 plugins/dali-script-v8/src/module-loader/module-loader.h create mode 100644 plugins/dali-script-v8/src/module-loader/module.cpp create mode 100644 plugins/dali-script-v8/src/module-loader/module.h create mode 100644 plugins/dali-script-v8/src/object/handle-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/object/handle-wrapper.h create mode 100644 plugins/dali-script-v8/src/object/property-value-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/object/property-value-wrapper.h create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-api.cpp create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-api.h create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-list-api.cpp create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-list-api.h create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.h create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/render-tasks/render-task-wrapper.h create mode 100644 plugins/dali-script-v8/src/shader-effects/shader-effect-api.cpp create mode 100644 plugins/dali-script-v8/src/shader-effects/shader-effect-api.h create mode 100644 plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.h create mode 100644 plugins/dali-script-v8/src/shared/api-function.h create mode 100644 plugins/dali-script-v8/src/shared/base-wrapped-object.cpp create mode 100644 plugins/dali-script-v8/src/shared/base-wrapped-object.h create mode 100644 plugins/dali-script-v8/src/shared/object-template-helper.cpp create mode 100644 plugins/dali-script-v8/src/shared/object-template-helper.h create mode 100644 plugins/dali-script-v8/src/signals/dali-any-javascript-converter.cpp create mode 100644 plugins/dali-script-v8/src/signals/dali-any-javascript-converter.h create mode 100644 plugins/dali-script-v8/src/signals/emit-notification-interface.h create mode 100644 plugins/dali-script-v8/src/signals/signal-manager.cpp create mode 100644 plugins/dali-script-v8/src/signals/signal-manager.h create mode 100644 plugins/dali-script-v8/src/stage/stage-api.cpp create mode 100644 plugins/dali-script-v8/src/stage/stage-api.h create mode 100644 plugins/dali-script-v8/src/stage/stage-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/stage/stage-wrapper.h create mode 100644 plugins/dali-script-v8/src/text/font-api.cpp create mode 100644 plugins/dali-script-v8/src/text/font-api.h create mode 100644 plugins/dali-script-v8/src/text/font-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/text/font-wrapper.h create mode 100644 plugins/dali-script-v8/src/toolkit/builder/builder-api.cpp create mode 100644 plugins/dali-script-v8/src/toolkit/builder/builder-api.h create mode 100644 plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.h create mode 100644 plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.cpp create mode 100644 plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.h create mode 100644 plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.cpp create mode 100644 plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.h create mode 100644 plugins/dali-script-v8/src/utils/v8-utils.cpp create mode 100644 plugins/dali-script-v8/src/utils/v8-utils.h diff --git a/build/tizen/Makefile.am b/build/tizen/Makefile.am index 1ff34c2..f633e75 100644 --- a/build/tizen/Makefile.am +++ b/build/tizen/Makefile.am @@ -14,7 +14,14 @@ # limitations under the License. # -SUBDIRS = dali-toolkit docs +SUBDIRS = dali-toolkit + +if ENABLE_JAVASCRIPT_PLUGIN +SUBDIRS +=plugins +endif + +# perform documentation last, so it doesn't prevent code from building if there's an error +SUBDIRS += docs pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = dali-toolkit.pc diff --git a/build/tizen/configure.ac b/build/tizen/configure.ac index 4c4afda..c1858ef 100644 --- a/build/tizen/configure.ac +++ b/build/tizen/configure.ac @@ -46,14 +46,27 @@ AC_ARG_ENABLE([debug], [enable_debug=$enableval], [enable_debug=no]) +# option for JavaScript plugin +AC_ARG_ENABLE(javascript, + [AC_HELP_STRING([--enable-javascript], + [Enable JavaScript plugin])] , + [enable_javascript=yes], + [enable_javascript=no]) + if test "x$enable_debug" = "xyes"; then DALI_TOOLKIT_CFLAGS="$DALI_TOOLKIT_CFLAGS -DDEBUG_ENABLED" + DALI_SCRIPTV8_CFLAGS="$DALI_TOOLKIT_CFLAGS -DDEBUG_ENABLED" fi if test "x$enable_debug" = "xno" -a "x$enable_exportall" = "xno"; then DALI_TOOLKIT_CFLAGS="$DALI_TOOLKIT_CFLAGS -fvisibility=hidden -DHIDE_DALI_INTERNALS" + DALI_SCRIPTV8_CFLAGS="$DALI_TOOLKIT_CFLAGS -fvisibility=hidden -DHIDE_DALI_INTERNALS" fi +#set a variable for the makefile to conditionally compile the plugin +AM_CONDITIONAL([ENABLE_JAVASCRIPT_PLUGIN], [test x$enable_javascript = xyes]) + + # Tizen Profile options AC_ARG_ENABLE([profile], [AC_HELP_STRING([--enable-profile=COMMON,MOBILE,LITE,WEARABLE,TV], @@ -76,6 +89,8 @@ fi AC_SUBST(dataReadWriteDir) AC_SUBST(dataReadOnlyDir) AC_SUBST(DALI_TOOLKIT_CFLAGS) +AC_SUBST(DALI_SCRIPTV8_CFLAGS) +AC_SUBST(DALI_SCRIPTV8_LIBS) # Specify the include directory for development headers #devincludepath=${includedir}/dali/internal @@ -91,6 +106,7 @@ AC_SUBST(DOXYGEN_ROOT_DIR) AC_CONFIG_FILES([ Makefile dali-toolkit/Makefile + plugins/Makefile dali-toolkit.pc docs/Makefile docs/dali.doxy @@ -103,6 +119,7 @@ Configuration ------------- Prefix: $prefix Debug Build: $enable_debug + JavaScript support (V8 required) $enable_javascript Profile: $dali_profile Data Dir (Read/Write): $dataReadWriteDir Data Dir (Read Only): $dataReadOnlyDir diff --git a/build/tizen/dali-toolkit/Makefile.am b/build/tizen/dali-toolkit/Makefile.am index aab631d..e966482 100644 --- a/build/tizen/dali-toolkit/Makefile.am +++ b/build/tizen/dali-toolkit/Makefile.am @@ -111,6 +111,7 @@ publicapishadereffectsdir = $(publicapidir)/shader-effects publicapibubbleeffectdir = $(publicapidir)/shader-effects/bubble-effect publicapistylingdir = $(publicapidir)/styling publicapitransitioneffectsdir = $(publicapidir)/transition-effects +publicapiscriptingdir = $(publicapidir)/scripting publicapi_HEADERS = $(public_api_header_files) publicapicontrols_HEADERS = $(public_api_controls_header_files) @@ -129,6 +130,7 @@ publicapinavigationframe_HEADERS = $(public_api_navigation_frame_header_files) publicapipageturnview_HEADERS = $(public_api_page_turn_view_header_files) publicapipopup_HEADERS = $(public_api_popup_header_files) publicapiscrollbar_HEADERS = $(public_api_scroll_bar_header_files) + publicapiscrollcomponent_HEADERS = $(public_api_scroll_component_header_files) publicapiscrollable_HEADERS = $(public_api_scrollable_header_files) publicapiscrollview_HEADERS = $(public_api_scroll_view_header_files) @@ -149,3 +151,5 @@ publicapishadereffects_HEADERS = $(public_api_shader_effects_header_files) publicapibubbleeffect_HEADERS = $(public_api_bubble_effect_header_files) publicapistyling_HEADERS = $(public_api_styling_header_files) publicapitransitioneffects_HEADERS = $(public_api_transition_effects_header_files) +publicapiscripting_HEADERS = $(public_api_scripting_header_files) + diff --git a/build/tizen/plugins/Makefile.am b/build/tizen/plugins/Makefile.am new file mode 100644 index 0000000..d80dd67 --- /dev/null +++ b/build/tizen/plugins/Makefile.am @@ -0,0 +1,61 @@ +# +# Copyright (c) 2015 Samsung Electronics Co., Ltd. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# Build the Dali Toolkit library + +plugin_src_dir = ../../../plugins + +include ../../../plugins/dali-script-v8/file.list + +DALI_SCRIPTV8_LIBS="-lv8 -lpthread" + +lib_LTLIBRARIES = libdali-script-plugin-v8.la + +# force the source code to include the directory the wrapper file is in +# e.g. actors/actor-api.h to copy the same include style as dali-core +# The reason for including toolkit paths directly instead of just the +# install path for dali-toolkit.h, is dali-toolkit.h is not installed yet. +# It won't be installed until the rpm is installed, and unfortunately the +# plugin is part of the same rpm +script_plugin_v8_includes = -I../../../plugins/dali-script-v8/src \ + -I../../../plugins/dali-script-v8/src/utils \ + -I../../../ + + +libdali_script_plugin_v8_la_SOURCES = \ + $(script_v8_plugin_src_files) + +libdali_script_plugin_v8_la_DEPENDENCIES = + +libdali_script_plugin_v8_la_CXXFLAGS = -DDALI_COMPILATION \ + $(DALI_TOOLKIT_CFLAGS) \ + $(DALICORE_CFLAGS) \ + -DDALI_DATA_READ_ONLY_DIR="\"${dataReadOnlyDir}\"" \ + $(DALI_CFLAGS) \ + $(DLOG_CFLAGS) \ + $(DALI_SCRIPTV8_CFLAGS) \ + -I../../.. \ + $(script_plugin_v8_includes) \ + -Werror -Wall + +libdali_script_plugin_v8_la_LIBADD = \ + $(DALICORE_LIBS) \ + $(DALI_LIBS) \ + $(DLOG_LIBS) \ + $(DALI_SCRIPTV8_LIBS) + +libdali_script_plugin_v8_la_LDFLAGS = \ + -rdynamic diff --git a/dali-toolkit/dali-toolkit.h b/dali-toolkit/dali-toolkit.h index 70f9652..2acf635 100644 --- a/dali-toolkit/dali-toolkit.h +++ b/dali-toolkit/dali-toolkit.h @@ -21,7 +21,8 @@ #include // Toolkit - +#include +#include #include #include #include @@ -85,6 +86,9 @@ #include +#include +#include + #include #include #include diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list index da91a77..bebe657 100644 --- a/dali-toolkit/internal/file.list +++ b/dali-toolkit/internal/file.list @@ -95,5 +95,8 @@ toolkit_src_files = \ $(toolkit_src_dir)/transition-effects/cube-transition-effect-impl.cpp \ $(toolkit_src_dir)/transition-effects/cube-transition-cross-effect-impl.cpp \ $(toolkit_src_dir)/transition-effects/cube-transition-fold-effect-impl.cpp \ - $(toolkit_src_dir)/transition-effects/cube-transition-wave-effect-impl.cpp + $(toolkit_src_dir)/transition-effects/cube-transition-wave-effect-impl.cpp \ + $(toolkit_src_dir)/scripting/script-impl.cpp \ + $(toolkit_src_dir)/scripting/script-plugin-proxy.cpp + diff --git a/dali-toolkit/internal/scripting/script-impl.cpp b/dali-toolkit/internal/scripting/script-impl.cpp new file mode 100644 index 0000000..8b08f99 --- /dev/null +++ b/dali-toolkit/internal/scripting/script-impl.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include "script-impl.h" + +// INTERNAL INCLUDES +#include +#include "script-plugin-proxy.h" + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +namespace +{ +const char* PLUGIN_FILE = "libdali-script-plugin-v8.so"; +} + +void Script::ExecuteFile( const std::string& filename ) +{ + if( mPlugin ) + { + mPlugin->ExecuteFile(filename); + } +} + +Script::Script(void) : mPlugin(NULL) +{ + ScriptPluginProxy *plugin = new ScriptPluginProxy( PLUGIN_FILE ); + + if( mPlugin ) + { + DALI_LOG_WARNING("Reloading script plugin %s, is this what you wanted to do?",PLUGIN_FILE); + delete mPlugin; + mPlugin = NULL; + } + + if( plugin->IsInitialized() ) + { + mPlugin = plugin; + } + else + { + delete plugin; + } + +} + +Script::~Script() +{ + if( mPlugin ) + { + delete mPlugin; + } +} + +} // namespace Internal + +} // namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/internal/scripting/script-impl.h b/dali-toolkit/internal/scripting/script-impl.h new file mode 100644 index 0000000..ba4094e --- /dev/null +++ b/dali-toolkit/internal/scripting/script-impl.h @@ -0,0 +1,104 @@ +#ifndef __DALI_TOOLKIT_INTERNAL_SCRIPT_H__ +#define __DALI_TOOLKIT_INTERNAL_SCRIPT_H__ + +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// INTERNAL INCLUDES +#include +#include + + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +class Script; + +/** + * @copydoc Toolkit::Script + */ +class Script : public Dali::BaseObject +{ +public: + + /** + * @brief Constructor + */ + Script(); + + /** + * @copydoc Toolkit::Script::ExecuteFile + */ + void ExecuteFile( const std::string& filename ); + +protected: + + /** + * @brief virtual destructor + */ + virtual ~Script(); + +private: + + /** + * @brief Undefined copy constructor + */ + Script(const Script&); + + /** + * @brief Undefined assignment operator + */ + Script& operator=(const Script& rhs); + +private: // data + + ScriptPlugin* mPlugin; ///< plugin + +}; + +} // namespace Internal + +inline Internal::Script& GetImpl(Dali::Toolkit::Script& obj) +{ + DALI_ASSERT_ALWAYS(obj); + + Dali::BaseObject& handle = obj.GetBaseObject(); + + return static_cast(handle); +} + +inline const Internal::Script& GetImpl(const Dali::Toolkit::Script& obj) +{ + DALI_ASSERT_ALWAYS(obj); + + const Dali::BaseObject& handle = obj.GetBaseObject(); + + return static_cast(handle); +} + + +} // namespace Toolkit + +} // namespace Dali + +#endif // __DALI_TOOLKIT_INTERNAL_SCRIPT_H__ diff --git a/dali-toolkit/internal/scripting/script-plugin-proxy.cpp b/dali-toolkit/internal/scripting/script-plugin-proxy.cpp new file mode 100644 index 0000000..1e0a6c2 --- /dev/null +++ b/dali-toolkit/internal/scripting/script-plugin-proxy.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include "script-plugin-proxy.h" + +// INTERNAL INCLUDES +#include + +// EXTERNAL INCLUDES +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +ScriptPluginProxy::ScriptPluginProxy( const std::string& sharedObjectName) +: mLibHandle(NULL), + mCreatePluginFunctionPtr(NULL), + mDestroyPluginFunctionPtr(NULL), + mScriptingPlugin(NULL), + mSharedObjectName(sharedObjectName), + mIsInitialized(false) +{ + Initialize(); +} + +ScriptPluginProxy::~ScriptPluginProxy() +{ + UnInitialize(); +} + +void ScriptPluginProxy::SetFlags(const std::string& flags) +{ + if( mIsInitialized ) + { + mScriptingPlugin->SetFlags( flags ); + } +} + +void ScriptPluginProxy::ExecuteBuffer(const std::string &buffer, const std::string &filename) +{ + if( mIsInitialized ) + { + mScriptingPlugin->ExecuteBuffer( buffer, filename ); + } +} + +void ScriptPluginProxy::ExecuteFile(const std::string &filename) +{ + if( mIsInitialized ) + { + mScriptingPlugin->ExecuteFile( filename ); + } +} + +bool ScriptPluginProxy::IsInitialized() const +{ + return mIsInitialized; +}; + + +void ScriptPluginProxy::Initialize() +{ + if( mIsInitialized ) + { + return; + } + + // dl library maintains link counts if you call this twice on the same library + // (so its okay to do but we should close every handle we get too) + mLibHandle = dlopen( mSharedObjectName.c_str(), RTLD_NOW | RTLD_GLOBAL ); + if( !mLibHandle ) + { + DALI_LOG_ERROR( "Cannot load dali script plugin. %s\n", dlerror() ); + return; + } + + // reset errors + dlerror(); + + // load plugin + mCreatePluginFunctionPtr = reinterpret_cast( dlsym( mLibHandle, "CreateScriptPlugin" ) ); + if( !mCreatePluginFunctionPtr ) + { + DALI_LOG_ERROR( "Cannot load symbol CreateScriptPlugin(). %s\n", dlerror() ); + return; + } + + // reset errors + dlerror(); + + mDestroyPluginFunctionPtr = reinterpret_cast( dlsym( mLibHandle, "DestroyScriptPlugin" ) ); + if( !mDestroyPluginFunctionPtr ) + { + DALI_LOG_ERROR( "Cannot load symbol:DestroyScriptPlugin(). %s\n", dlerror() ); + return; + } + + // reset errors + dlerror(); + + mScriptingPlugin = mCreatePluginFunctionPtr(); + + if( !mScriptingPlugin ) + { + DALI_LOG_ERROR( "Call to function CreateFeedbackPlugin() failed\n" ); + return; + } + + mIsInitialized = true; +} + +void ScriptPluginProxy::UnInitialize() +{ + if( mScriptingPlugin ) + { + mDestroyPluginFunctionPtr( mScriptingPlugin ); + } + + if( mLibHandle ) + { + if( dlclose( mLibHandle ) ) + { + DALI_LOG_ERROR( "Error closing dali plugin library: %s\n", dlerror() ); + } + } + mIsInitialized = false; +} +} // namespace Adaptor + +} // namespace Internal + +} // namespace Dali diff --git a/dali-toolkit/internal/scripting/script-plugin-proxy.h b/dali-toolkit/internal/scripting/script-plugin-proxy.h new file mode 100644 index 0000000..72f5e15 --- /dev/null +++ b/dali-toolkit/internal/scripting/script-plugin-proxy.h @@ -0,0 +1,106 @@ +#ifndef __DALI_INTERNAL_SCRIPT_PLUGIN_PROXY_H__ +#define __DALI_INTERNAL_SCRIPT_PLUGIN_PROXY_H__ + +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal +{ + +/** + * @brief Proxy class to dynamically load, use and unload script plugin. + * + * + */ +class ScriptPluginProxy : public ScriptPlugin +{ +public: + + /** + * @brief Constructor + * @param sharedObjectName so file to load + */ + ScriptPluginProxy( const std::string& sharedObjectName); + + /** + * @brief destructor + */ + virtual ~ScriptPluginProxy(); + + /** + * Set engine configuration flags + * @param [in] flags string. Format dependent on the scripting engine. + */ + virtual void SetFlags( const std::string& flags ); + + /** + * @brief Exececute the buffer contents as a script + * @param [in] buffer script file contents + * @param [in] filename a nominal name for the buffer contents. + * (NB filename extension may be used to disambiguate script language) + */ + virtual void ExecuteBuffer( const std::string& buffer, const std::string& filename ); + + /** + * @brief execture the file as a script + * @param [in] filename the filename to read and execute + */ + virtual void ExecuteFile( const std::string& fileName ); + + /** + * @brief check if the plugin is initialized + * @return true if it's initialized + */ + bool IsInitialized() const; + +private: + /** + * @brief Dynamically loads the script plugin. + */ + void Initialize(); + + /** + * @brief Unloads the script plugin. + */ + void UnInitialize(); + +private: + + void* mLibHandle; + ScriptPlugin::Create* mCreatePluginFunctionPtr; + ScriptPlugin::Destroy* mDestroyPluginFunctionPtr; + ScriptPlugin* mScriptingPlugin; + std::string mSharedObjectName; + bool mIsInitialized; + +}; + +} // namespace Adaptor + +} // namespace Internal + +} // namespace Dali + +#endif // __DALI_INTERNAL_SCRIPT_PLUGIN_PROXY_H__ diff --git a/dali-toolkit/public-api/file.list b/dali-toolkit/public-api/file.list index 85a3702..cbe5e77 100755 --- a/dali-toolkit/public-api/file.list +++ b/dali-toolkit/public-api/file.list @@ -99,6 +99,7 @@ public_api_src_files = \ $(public_api_src_dir)/transition-effects/cube-transition-effect.cpp \ $(public_api_src_dir)/transition-effects/cube-transition-fold-effect.cpp \ $(public_api_src_dir)/transition-effects/cube-transition-wave-effect.cpp \ + $(public_api_src_dir)/scripting/script.cpp \ $(public_api_src_dir)/dali-toolkit-version.cpp \ $(public_api_src_dir)/enums.cpp @@ -274,3 +275,7 @@ public_api_transition_effects_header_files = \ $(public_api_src_dir)/transition-effects/cube-transition-fold-effect.h \ $(public_api_src_dir)/transition-effects/cube-transition-wave-effect.h +public_api_scripting_header_files = \ + $(public_api_src_dir)/scripting/script.h \ + $(public_api_src_dir)/scripting/script-plugin.h + diff --git a/dali-toolkit/public-api/scripting/script-plugin.h b/dali-toolkit/public-api/scripting/script-plugin.h new file mode 100644 index 0000000..b40dcb4 --- /dev/null +++ b/dali-toolkit/public-api/scripting/script-plugin.h @@ -0,0 +1,85 @@ +#ifndef __DALI_SCRIPT_PLUGIN_H__ +#define __DALI_SCRIPT_PLUGIN_H__ + +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +/** + * @brief Abstract interface to provide scripting support. + * + * A plugin must export the following functions to create / destroy the object + * CreateScriptPlugin() // returns a pointer to a ScriptPlugin object + * DestroyScriptPlugin() // destroys the plugin + */ +class DALI_IMPORT_API ScriptPlugin +{ +public: + + + /** + * Function pointer called in toolkit to create a ScriptPlugin plugin instance. + * @return Pointer to the newly created plugin object + */ + typedef ScriptPlugin* Create(); + + /** + * Function pointer called in toolkit to Unload the plugin. + * @param plugin The plugin object created and returned by CreateScriptPluginPlugin(). + */ + typedef void Destroy(ScriptPlugin* plugin); + + /** + * virtual Destructor. + */ + virtual ~ScriptPlugin() {}; + + /** + * Set engine configuration flags + * @param [in] flags string. Format dependent on the scripting engine. + */ + virtual void SetFlags(const std::string& flags) = 0; + + /** + * Exec buffer contents as a script + * @param buffer script file contents + * @param filename a nominal name for the buffer contents. + * (NB filename extension may be used to disambiguate script language) + */ + virtual void ExecuteBuffer(const std::string& buffer, const std::string& filename) = 0; + + /** + * Exec file as a script + * @param filename the filename to read and execute + */ + virtual void ExecuteFile(const std::string& filename) = 0; + +}; // class ScriptPlugin + +} // namespace Toolkit + +} // namespace Dali + +#endif // __DALI_SCRIPT_PLUGIN_H__ diff --git a/dali-toolkit/public-api/scripting/script.cpp b/dali-toolkit/public-api/scripting/script.cpp new file mode 100644 index 0000000..5fbb1e1 --- /dev/null +++ b/dali-toolkit/public-api/scripting/script.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include "script.h" + +// INTERNAL INCLUDES +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +Script::Script() +{ +} + +Script::~Script() +{ +} + +Script Script::New(void) +{ + return Script(new Internal::Script()); +} + +Script::Script(Internal::Script *impl) + : BaseHandle(impl) +{ +} + +void Script::ExecuteFile( const std::string &filename ) +{ + GetImpl(*this).ExecuteFile( filename ); +} + +} // namespace Toolkit + +} // namespace Dali + diff --git a/dali-toolkit/public-api/scripting/script.h b/dali-toolkit/public-api/scripting/script.h new file mode 100644 index 0000000..53c82aa --- /dev/null +++ b/dali-toolkit/public-api/scripting/script.h @@ -0,0 +1,91 @@ +#ifndef __DALI_TOOLKIT_SCRIPT_H__ +#define __DALI_TOOLKIT_SCRIPT_H__ + +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// INTERNAL INCLUDES +#include +#include + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Internal DALI_INTERNAL +{ +class Script; +} + +/** + * Script + * This class provides the ability to execute script in a supported language. + * Specific script language support is provided through plugins. + * + * For Example. + * + * @code + * + * Script script = Script::New(); + * + * script.ExecuteFile("bump-map.js"); + * + * @endcode + * + */ +class DALI_IMPORT_API Script : public BaseHandle +{ + +public: + + /** + * Create an Script handle; this can be initialised with Script::New() + * Calling member functions with an uninitialised handle is not allowed. + */ + Script(); + + /** + * Creates an Script object. + * @return A handle to the Script control. + */ + static Script New(); + + /** + * Virtual destructor. + */ + ~Script(); + + /** + * Executes the contents of filename in a scripted environment. + * @pre A Dali Application object exists + * @param filename A filename of a script file to execute + */ + void ExecuteFile( const std::string& filename ); + +private: + + Script(Internal::Script *impl); + +}; // class Script + +} // namespace Toolkit + +} // namespace Dali + +#endif // __DALI_TOOLKIT_SCRIPT_H__ diff --git a/docs/content/images/screenshot.png b/docs/content/images/screenshot.png index d42964d2efa81f71f87cccf1200619169f945dd4..913d9f096832af17b27200e4c497a75a938b8c6b 100644 GIT binary patch literal 469534 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%0A11VZ`8ojLova@Tub$N%D5lc|F8y@a=&Zm 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 literal 244509 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≫n<0YDUr!c6M>x7n9`yMLDBbO$xtIyWwKUint~57 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

? zs0IbY2o4?!^bvZ+?hbM&vd`=abP<+C@NplCaKk^b?8blS$CDocmp=Mrho+Sn|95z` zBQ@*f=f)J3)oXUHTfJuY&-7hib59SY1Y7sE{|bNb$-n1;qI~1u*th<_7wv}mrqofH zO2TYy&58aP#}~(0t2d~O<5<^8H<+X#I%Anm8bXxVp=n*=#&L2{YDAP(ge+dk5TqbP zG$m=ws7x(I{BlOgY1>&xijh9cjdD^=2%%%U^Tg3q-P9H6L~9##5%S1UG#P1j*m1!A#hfhJ&rnX|*RyYGbEa{`i;83Pv;X7jVRK|f4U^(Mz zM3qF-RxG-}5HgjMA`_!@c>C6;%=-bK0*!0%A%M;_uEr`T#YpN1iIheBBZ1DDVG#R= zby^Zp096vTGsKWNdLmM?!Bj@}r6fubQcX?;>lDr?7R!VmGL=&l3L6`irmhGf5K_%DPXjrtrYv#M6@&S5+@dsMJK|n7)PG& z2ocX?mf&;(gHH^-bk5Fbwzq`ZlS?6IMcr67Hxa&V(K0bfMaH9K=^9hQYE2jl^JS7z ztJ6Z_v10FND~I=y#lnx?Uqw-6q^fB`*1Y`}`g__j!YoCq(GwG*Bq~=`&FfzGI-c^B zr|_1yyoKjI?|EEz-E}Yc4bA@zXBiE z3apg^dSq0uo~g%N)v?Ih5h$L@NrBDI$TRPJTu#EKcM7Cl=~9%HD!v<9yb?iWt^EDS z%IC*IYaLW$q5pmhX@DE^Ki|T5-EHucM>FygPZiSKNu8=s^*!#2amKZU;?&(_*)xXS zxu$#_g)x0SnOpzJj}!wcSA^V=vM1`Du4fCY6lYG(q8kQI^xGU;bP@(&9VA06g~LY& zbQP&9u^NPsFxoJwTh>}jmn9x*(VxH>H;$LGjB4XjZa_v+88QEdEMgPuEGmd6Y^~Bz zuMzwSmNAoaV$t^V;O4ZFG^56~IIZY?q;Z;!sZfY0;A6&zft(b&F-%-VOoqi=p3|^M zXV3aR!;Y^a_(&*)<+iB&U8UGq*Q`w~y-&m}9c0P^W6v>D>4KR# zs>aEvJ3%R##Za*3o>-}4VK~Dm8U@GZOExw(ST2_g!@vzU+`!NN?9cML*S(H+zx&<1 z=}m9q3t#vG=bn2mkNfs-XF8ptwdUy2qg;Re^?2`j#VcOHWtUyXhd=yb{{6py1*K%x z*4FS|d^pFB9iz3Dbqa1QPHH6(c$I#mS40r2Ox3cdpq3RCVOc4rxxk?$H_p?>0++`w zbVqfXR|;1e3!)jN{5v1#v8e3`Khz#k$!=z2IT=57N<7udpY0T4D}q@bZsB$>-R3{X z$4v*}!~)vtq}p`#cUC-!g*|)7yHc=nYDxzyg_G69j(aMMJEvW~*@Y1nVT*#Cocm$P ztZi`P>9=-@eX}Wjtf^d$#!=~pr5!kOV#(Ilf<)r%bBrX=SB97heabLIj%_coD$C6< zE@&o(eX}XnDqPWIf_Ub#r(b%|hLAF|$_PxHLQ$TQEm~*VTCqMAp^nvV>=*<#pp`+n zoSd=L{t(N|55R z=$9jT#?a3POyw{R=6z3_YYc^LzeVLVIcnzJz;xn9U$z$IZj8*@2_XbxEHqWkqDyQ{ z9nMY|hC<1aX3~(*U>!Oal&a85VzcJUooqu`c9|GpV^#^0Eo)%`m%ywtthX(TVL=)q zjd9dYv(~own1pXyRfOoNw8mM(GC&wIZQG)hrE-z=^&TI<`_c3dOlwC7L7r1K#F(*K zc7MiLRB_}u;Inj9F(#H>A%={zg=IHtDN4o<5v2=tV>oT2q2wsjhQ?u#n6X?0O7Byq zPcZZ%aB*g(OvS5HJ10h=RK5Cc;zc!$*=zEuk!Jaf1Dd{ym6Oc1F(Pp zejfI)hw+%lJciB9O@8-xf0x(3_O*0fM>XbaS!;35VXR{#dNzZ)Q=&%ZF5;(Fe^)2z zI7OXWP_sIum15B>hmK`m z@V&vblDVi-q3bhBC6+qVI*qjxDL%fJB3B9}XNDkqw2&dDM9IULiKs+kkEFn#n4cI0 zEfsMHlGT_rAN%TYuD$JVc*3_{z$0c8{_@%{qr2m{qNxbn^d-l^!!7r_-wB!~Ndkp6 z?5i76&K%i_OsX2K3&&3^utTDqI;{Es$$OI@Nz?qk@AIth5=&<7y;UzWJwwiLIHW;y zF=*4$7?flgFd)$uU>Ww&cOMM+VCZ1@V!(fa4>}kieKJfNpbnA^!XRnWf;b{)hTStH zr)PSt>e@0hmUnqpAD%ZdBcn3AhoqsRh5=M}Rz*fuR%FEUeZRlochU6YKw}kF36`~C z7&BT(Dyy+t;XKT2g`EYI)HqYtJ5^=5dn9qOCk2J6Th6)--t{=2OKG$$os=$&7+5xzw$cofB33sIN|f5EoXc|~$oM=UN6Fi zX9y{owThcd!K`Xo^@(AGN@)h+iLqG3LQHhM#~Q3IPk_nk1jOD;L8mtnfLo$NU zC0HP*OmKm$648p1wv-~PttST1R^i520MtmDR}w7L2>tah|=HqQwjb!{`JGfoZ-XA7vsx)#wgPTKpy%R z4;8Gt77m#XtR9CzDf!%-J2Cz2U-WHs12IHywnsQOkO*wgBH0R}tMC!}O(Zy5V$#Nz zAWEjOF$&XUlrW?xN4WS5T~}1K#3X^pg4vA*@4I44(w5EW=(`cG%HFE7k*-UO-eIgI z!_ag*pB-+B0q_r+b_dix1N43Gt#@93UVhTl_ zC}a_6bgrbOghbn9LRd5UgwYnC0=*Oj@9BrcX4n#wU{))ng5LGyEUB%6ENE<13Uf>U z6@BomyMQ&NO36`*lpE6^F{p{f6+K_#Y*X00l!hEN2uWR4)Bdc&k?4Fth{UWhRK_r` z4Vlb()6uySN!)#5@%IEQS2AWCs?0-q#Wm3EH=)6!leMPPK95X(-m zA0yTze2nxiqJ%<`u!fRPn@W!A;6~h#aUx-@f|NKr^LU@AYDdhGx>AJbscVgM85hd) zmVvAUql;8ppleB;Gd^TCn=%?5`-~p~w_mZC#vo##vVvR*LX*iz^vDE^f_hez$6jPy zFYy7C2`DYlS|YWiA0qWN7rp0p4I$vA;P@Ine>iJVQnFsJY1=YpsOy>#0^j`RH+kos zclh;R|8?Ge`)%&ty^FP$VHkMu-~k_h^bzlW@B!=f8ef`%G`g0{1(x4vhZi zc8`29I=!@GJS;i>5m;>cE5I20aYgo;oEmbtMJ*y}JjHD*l(3{hv#bPBI$RcrDv=|I z6i`AGh9?x#E9}`zS>e$D>Iu;fGR#f=OZqZ zH=U9RDKp!Cq^%5-^GBbY^5BOzdGqZJN3)2Krt}j=a6TXyrqBa65_z1DC<%34lSuef>YE1dk-l883=Tq)4Cj?w8Y^M!djf*> zPyz^UEo)k1aWRl{A|#2;fumWCbBTFfTmUh}64V_7y`$JSVxSu$!BKh~O?hKTS>oD! z1fvz!lv3ly2zd5L@rnaBc$0#WMdw;|Ce7KzPN6OMP4W}n3<$zZj?;X|}oEv%Pop<>5x4%8* zrb0Lp0D5dbuqvuOrdif>h^EofS_8POrf_i<%@$da#e6?F+#1&)H0|vOGggIZ* z0Ec90WDg#;(Dh+^)j!U}exn>c}a8vDEb3?pWpy zM3cDO<9H<=hRZv~7ak&R6j=#2>z=lKgWGq$%-TNWhHwC&L*QR({JD=IQ5S@tjCpyRk3Jla*XtS zz{h|Q#cCm^PDJlY*|agH)QRO1WoL~glW^V>MO``~aVTjpy4Wz30%a0Lm&m^{CUO?k zwWh5#5Kum0v>*l$x%eL?B`U65n3RhHk;=t_(nU!tl_G}B&_$#vmYuQB)N_ecWpq1^ z5v@xrNX&u}!8n%C_~;Rx6%9e#~mU!aGmbm3GKD z`HZZ!R8@sBhNI(S7KK zdmYm4T?qWeW2Lx6IL|*g55|eG`q>Ls8vhFX0CLV$R+HyFo7MO5PGGB7c=@fbGn{(hr&Sx;@zA}C_+*QnaPycHXj4He%cpj zvMUjG$!D}y*j$8CDJ5p}^6t_SvM8$EL?R1`otnk9O8DsMx?KF9N)nR8Rs!!e+GsK! zT`Nj`i$L2V{%Pi!EaW7Fg0U-AQ$l58gl#wAU8bE01cG7oh*U&WDV1DSA0kyNkSdW< z**~t<#rN57Bc@g)S1z(cNM$cRSv}m48FNNi@i~lfVk|c$d@+pZfA+ug^jrUe&0BBN z-@ePucE;;p{R)FrjN^!RC8{ZfP}ri7D6KF`QX#0eYs?4lQTILahu=p&{uG%KmdsJk zyewcLE+0($U5s)cEU(!qUQ(}Kp;+C4qTDl=@Bewqu$dH$H&tPfdfIU*0Y+T-BG17x zO&{-#U-wPuyRUoB91p}C`zqCaL5@7wJ>HRUTf(CsGh|f25pZXEKA!_WH~l*Nb1sA8 z;eCf-X;)W&&U23ummjAboc{F1&+V@QFxK@EMryY1l=ir1+|ARgA2#i@R*s zPv|{J5zxBf_M+vrd-rG;OSBNhyC*76wvN*Q?k;XnV`1#r4)0P`4r^yfA@DJ=?H%I~ zsBAI3=Nw67q%v4z0m;^lSY^36o8yu{@3_-av1lw~=x{z0a$-@}7-QKCo^2l>moR`c z|1L{jifAH}s?+y#zyg#5Dfwh{M zY3Q9}Gr9tXBJgOvqSgvUK$7rrU^^uT8Bw!!B{*B;gdZJV365rpVWikDvLNJ$z(E#B zO5=l+nv@fDWlDg1j#Nezm3xZB6ibHmq9wxX>yAq=>f zse~a5j}ihQ6~i!+q9XW!5FU{;$Fm9{0x1dl9+KLU5X@{%H;nk`N=P`6y~Ai-Y$d@X zWa8G5DdXL~h@ol?tu?rq*$j!cQ6=`z!@3)YspR46sLGj`N?VBwWv{pHB2orSEs7mT zs}dV(1tJBkDS5jh3uX(&)|Vt3LGdb9He-ZhaFOjM;)fD?pb#b9M+&47WL-c{$f9c* zx)NqlHKlX0Ta_v_qZKK^7!q*+A2QmOcX_6KEJ!ToSJ!K3$=<#tLo48osn>A+=_jlo ze1fCwzd{BtVVp1Mni(z?xpQ(35d$U$bcom~TU1Zh2qU19r8{vZ;7CHf1Cc#Y*}v*P zS9o5*Bt?FH7kNp5v)9sb{`kG!2*MLK2{gcPZGpufTG~)k^JtpajE|^ zJ}ZZOJ56y5yS*$95PPBh1?xtrSWKbOjPk$dXED7BwW9sAihhO8WIDtWN}A zed|qbK6=W7Cr|nK$uoZL%QxAs2im4#M&=|(-k1qK@tXHPd7Gwvk9M|VtvzO{7K$;^ zv=YQfNR}KFW1lcOGH(J>OBU^%<9W-|vlTv+D6zTY1m zD4{uOT0$BTGN7fx^@`P|*m5e9Nh#xFz$(cnk2`z-+myXQFC2?`!>7+SNZnDll9VK~ zx?D6xGL2HWM6v4_iHMnuC|$OyTnO1JPvyXoq03lfKx$$TD3#F~l(NW}xOr1CZZjcx znp&69btoCZqoiDbtIBX& zz)F^Og^`lp;sCc@<2P%9xCnmU37fQv~dVFgs8{N9L*mWnj(>d2RssPYP9|DpKi zy8U6^+gGY3!a{?!1es(m)_#mQOi3& z{FGOvSvt*e)L7%4Hzl$Xhc?2R^XCjGnR0H;1fbRW=%_NBq@zp zB{*Ibwmim!OJIaXh>Q=O90kf~Of9iVp=2!mjyWJwsSpzrfiN;qx0OeBV(s9&{}kRv(5dgDIZu5n&JHGxwz0oo19p&WLs5%8)A zSR$7*Ft6JGuxA_FF~pdkZ_zm1|2+qUS1D7kcw9c*Nq)vi_3&%$z;P}wi*EMK{`&%) z-F@;3OPtu-gXROE%m*UYb5Kl|8KeO2%MvB`e){nOMtK!myap8I;p^ou0E+TpVj#u! zUo!(!83Hj)F@V!p{YBig)`Sr8DS&{@xI*R37vHvg_$xDUbMhmPPq zIh7c#FnWwu+*~XPGULZB_io>&ZDxG?2cPiWcfZFQ_urs9dz;aJo2r3T?`h-6ysA-h zGEPU0QIgFt;9P_ph$LoJVhp8TNQ=y^qlTt#IP1>nhSJYBuQWcEC^=&qdOxyS_l#Df zlmQ(u)d!55hcxvUY3deY;E(>~2i!Y8LUo>b8?n}~di(@8JEmRS!1?p~+bz zvLt8EysA0d4pUuK*>N4s8rrIXn6MgL8nD)qawaCtws-W-GoM!sp(p0dvYuf~#mT1F z*6LQ{Mn~6ss#;?!${R2G$!xknw=LPN+fCWQ8U;xek(9BT#ZoZzg40#R+DXTfQfUN{ipqeR zM}(wgr1lv<3Z#&Xqd;sERjrY#cq!u;2szO#i?TT8L{nGzA=0m}0Y>%?h<$+E0g;{# z6)Os;od-h83sBtu|D}(2orig^4V}y8`$JX;mjyNZ2N?&V8?G3kW^rN4K4*p3**)@w zf^p|_+)RK!6Bnw~9U#U%unao}DK5b5vpjlv?|HorDE2{d_j?4~Q?U9m8L5iT1F`*a z={2AzKV!#u<)0sXjn8DBQ=CyuQ@h5l;o~n;M){Y#Elq`*X<{n%LYYhw0-+RN{)q)c z=lSH5-{Z?~{Th`8Ng%|)v!~Bk-nfa>HK8AnGBQ}h>gh+s;J9(`6>cwQth*z!fbW0z zJ=SM|m%kvm{W`=v(D{hb70zYW-9Tk6T56&yKD&?{0)>#x(h6tmib)c*N#3U zq$oiHs0x`A^V$%m7``AAx>C$$6(MQHh0@+9dLO6^2qKl0xKS~VrJQ*)Zjb_o-Xn!(IWssP zs7yIXm6YUEMy|73p_F0M!{8&0l_ep_$caP*d=Lnsn9U_hl+c19xYF1Xpsgfw%GnLE zyuLGFtwC6YM3pXIA9?m@64{+;qCT!`(w+U-)z6nPVS9N57njng|O)gRwxhma|e%m zPJr_n5pw&MwtNr*pr+5+rUG~~bpeR#01$To8TS;WSDl^vnVg4=F<-|X_xz1=Dp7vp z$7rPbd85uB1r)`f0~F=KNcQu9Hcw1(H%fic*CR1`#$hC(=*E$GQ(>)UGk69EwUOMq z+wlkQ{1#t+^XuGQzRC=VA5Z8{PH2yAVcME;*iyN`@$Hv+dUnFuv!@)*7rgPxJx(?w zcVBsfv44k0A7q4z+)iwPP>G~cL^uv~0H;$>bVKa2}V>#e!1eIALC9JnSBGufQ z-=I;O5=*8nA5u{@xmaGMjo^ELxO>G2c+cSpI;e1hJDkZQ+QIX4e1XRXQE6uVoq?|b0Mj9&^{YVIr z5Con~JqKGEQWW&-#NbO#suGH4n=|^+VT_`ws_Ate(P<#WgsdzwW-x+;B8WV-Ul6m1-^s*s5fr8ZQ=Cvl}uFUC891BRw)T$^dur$8P=PTZtKZfla#`_Ox+r6Ef_k_I7F(MVi+>IE8*or zq|*4|B~~h|h3&TNgpZD|*)gX5fbKm|NeAMH!-IYwxVS<{amWg}LU6$W_@zUe1mJ!z4*ACOY=npW)i}_0A~k?T(HS70p;!hz6u=EHFl1}(W*Sy zJ?@fttbqFpe(b{)|xf^+0t8tBK?{5?12Pmb{*D;MPU&I4${=oK#V|Jjq6GahcSw#QPhNszK(vvQyW zv$m8D7k^{14Y}YD2BazB;YJHiAC-%qcA=@ICJ~ueiuKBK`qRSVNQogIyimO-r>jL-*e5uwa-lVN;R%c z!?`p%70=s04*ib#3V_`)Rtbz#y;VCUsv$%#LoNrC?Zp1ia6DF37;y#`E~uKvl&O$Sq2l zugsp+CNOVx8HM>sN)96-Q%0#;$#Z749ee636C#Y>GpjT)X4c!0VTh!xacPB&Yc}}} zZdI>xTpcq!dB!(CU13F{^PW+Z!++xpCPN6NS$;OpR5o*SZmDlI<$D?j%%Y*KT6`?e zWn~nN)%4>Qmt<+*iN1t^r-T-gT5D=k5kh1bJ)6E~+m{S!kp+6{b6js6DGBOYFb?Uw zNod>(a)1;^j+Yg;k1HOX^hha@WURCt-E0Urw*5$DHM7bfQ!FjJ1e8oPMxj+k>Wbbw zf)CiLV%v}Ssb@0^fs}%_HCUZ-PS6b!Eh}s*==#7gILO80=skGvNhzSEph=q1Cx$VQ z6L>%E_Cy(@ZdQq=wPXZJS-LSY_Am~Ps)g-1(jHC=xVFs1{BDEIbv=YpK+SDuo6WCi}#O~Rd*aLXHvue^zG z7qH!c(TK5!%^JNuBcGihe)y-TQ-7X?mh|4(G(Qhw=PdBL{UBFF$L)s#T*WRASmSec zkA3gs-k#LuvY>9%1vA_+NS({aW)CP8pR4t!M{x6bp!lQgCo>nL)SYViMcyi9xX~=gIkFzt z2%%VSJ2aA*CEk@$D^ifiERHfKPu}GZ{^Ti7S3k?kH(MTj{E$x{eax&foUJyrR&)Qg zS6DfC_~eYuW`(g8_g=csORv04Ghg!f(Nnf3FC&$u+x&p}G7+Mr>jjZS77nWoz57T%3hv#h(N)>oNny~Uc;jY`WQ@f= zl2a@OagmWo$eCqbA+l%mrH;u3i6AqM3GWp?l(@WEr4bcK1htjKQ4wUZBeb>PrMrgc zO5B_j8Dq+h)u*D!?ZQ~>7~T<*VF&|b2rN-#;gDId?Y2}F7PV#8YDS;wMu+#FnJpcQ z62r-MOKla$jmF0^rqsgVWgrl#jK({M8w0b(OkJ{(rdBi+WHLsTGUe4KAVfx4UDAq% z#EA@~py;+R4kM!zNC|zHAQS;m32IS9U!F%P%Lvv*SZ^a$E78I*Yz18($+7@%Q%OP) z^n<6e2JbSXOBhwsoP3DXR+2r$P`sqB4@e`qaa^%J^>`(n~TRdQ3dEWz=O2n2pTF|}zC00NGEA(Ig1vdA;NPqKX@_b1& z6#-Sm0MiMw`>)Iq6$3(R)T2+R|LFH={*V8a>i7OB`D~3)d!yC^^FG%JC-#<|`ITkzZqW4A-@w9iF_Fde-x(pxq!$Oiqk8+kDn>p5nvvc z0_xrC@kJB#EXqtFQ%YR55U31RNVHwxlV>~hc%SHoo<&=8|GweF_dn))?{9ebPv7M3 z-DCdj!w0l=MOD>ARrASdPwx}kzN4-ilq#XzA3bQ#ogWxf88x{|zn zr)BV6QG4cymX^v^NFzAi_6Vs-lc-|R&Um)%*mRzpB`2$5DxWPf$1{nN3Mq=nrLhJ? zCJ~rd;DV-enWGz$_4bE+>j(dgw_o}tzVg<6PKV6*-hY5|TXfyv{XGPa388pB^9buL zC~a5|!<2h!IqL?jDcy@IK@75c(xkp$AFn4&b*IoHW8&u zn?&yd##n@~JYDsm6fs2{18rS1N70yy7*nxOXvL;;JX@FY(Ht`|1ditw^Tyz!W7TEm zji9MCgDcT-N-MHV^nE4^O&*IEGv#u)G_!RgA6%xNp6`h?UGFSnjs@@eF6QeU&Q{M|CILIzt63I^j}bY_uFK3 zP!W|cdmE*AUUai>lHW(ts{}Wf#5V_wH09?lA?LOZae370Cl+C+R*o=*80^NY=O0hD zi_c<=dhZb4{hQ?>)607d@H*C$uZT;_SAge!Hzn|M8h%Q`AEy@wj#6CVEBsN-`+Sah z|BA5r&r8cW|GfnJu>5?*^q$EtxUBfBThn<*jKyTGg+|DXmI0#;V;`7RrW~G4F{P(C z^2#fUoI6gRe!^?7|2*&g*&nmou2={|mX1~bnBWtAObk9UZ!A(cy6!Oo#jMqA^!v#A zj9WJhBF`8`M?FuNQA4iKQkE-zB+ffhC{p-VX+jG42v!@c3d97aQPdXd8jKXosu~{y zr^A3qBb6ytO{0^nho0@2n71|aWyNas1ODIdKIRv{@^|^Auf55W^_r(Ak@aR^K5J2G zPK+BC?GkNEyG8I8pEf9+IO`JLJ8mCqa!^RA$w|-+0&6Pj%Cp+`q*&3|hHdYtQ~~$R zC~-02V`6ZL%1Tm{7+s?7wwp)=C?g?xd~iHDjVzi>TbYu{YBWNX{hhI(Q^L8xs&fn; zgpz2f83xC!HXJW%d`yrADy>*|fzc;U*Pe{Qj~StQUVgQt;hb$eLtnnPS8ukoRfUou zM5fge9}O{Q5(y1yb9oh(LB>fOb*%M-BF`FSt1RYUIVGRsU&@2pX zRpCa>y6cf5(prNLiJT--6}wSCdQt@22)a#VbDCHj3+lSGeJEM_9LK@aHWe`loEylw zC|2E&S>A$7L`X?pYc?k%!77%w8oKR>ND3tdS_x*AB-uc(1(AsJBc>Ag0ZvW>vzZ{~ z%;>{4j4@w`L*#S_4ENvU`~U4f=J7B6O$Jx!YhK6e)fCgg7WZ~+d6K4{17)7j1vvfc zFVX*_|B=`JtABv~_(PJu-n_pbBz{TN%JWGn&xvTbI)C-BmMZUCH}=PslK^H1m=PG# zUIo>3zuEIN>U_c4u4RlnQ2!iIln22194Ly*HiPRx@eqU)@Sj!iU-vK0!?**X=R`7p z5m5XQ6LLNm6!-othKod_7i}ROQ-t73d%S8e+K^Qy;?csOO-4(F5(cdrDx+BsTcRjl zzL)N8`2P3*3A5uFXR9+#HXBU8p|KXNHHwn6y4v*2>V&Ngj!#&J9wU3CPn@hu!EcI* z$0rGF;^q>hCq#WIK4au~-izb1FM9YbtIYzszRy z2%RI|nUahn9k-8Fzprk|+@E%Uqp-i`=K zi3=l22$oGtH|y}hm%#g!Ft%phCpLW|ctukQh7cHsKn@C*GMhdW(T`BnM$va=Dv)&< zHQFW-LWGp*oG0eM;4?x-Vt}TB`J%xJ&BI-95s$`35 zDX^6yrA$AjBC2v7gBz##I!(U~q?l1sp+w~7(lD!9*6WTjCbljilqH1B5Vi>1L4iY4J*3J5Ndbif$J z*adpiV@y%=jy|$l1!6QP1>0_<-zKycXamS{;n0ue>n(5S&lsidtQ85y`JC_mm;VDF z{p{Z)tP=ZFFke!UK~f>&lRr|QpOA zT`>yWw=7%*oR~tXHho14fNFvEj)&(9DiV zUQpQvWFq8*lm@K?IajRW1Lk%G39=9jV?rmvIQ0x_Eiuv%M!{m{IBE;y+ibUFA-UBq z8A8va)t27%kOWqj$TLRI*=FQqHE_IW>Bf;ECT6zOBK0ofLc+xX?iadIc4`t`M84~lEK&#@>o6jNSKWtynA-n=wokNr|>9s!lfsno1Vqd=j`& zjPa7l&4of&8KuCFppro&P)4G)Vlz7Y;804?G=bSn^K{)|EVMN&+X^i*V=U2VPfkaM zt>b7>(>4+<6paui*H&jlatu9a5=V1IPKw|otA2zisVwNMSj-x>W8(C*$7pD03Lzz4 zmmOqqk$I~KCNd<6bE!NxF5w+`6_GL_^R7B4lUydth*YLb0bIbS#QeD8EDMH>M=QZ5 zMuaRu_?b*q86aaURFy>OM4l9)DUYNeSe?jgMycX*fb&Pc__z4s*M5a@NRuLJuLo~` zR5}5j67bfd#QuD+&a8cYUWv(N0YfH}E6ayp{~H{?{6BN_@B^~C5S|Bba(|IGBLrGhbUxtx zi1QvJGo~)%N|`bak5ZbH5`zzHx`D^fdd8S&TTQiqm+xy_*Rg&$E8)y~P7)FC6Sf{O z_G8i*AeVsUlwAplMk9oxHky#j-s|?VMWvz~bRi&Rg;bJ9n++j&o@@h);|fE@rvaS} zLTN(msI0|DfmVu{)@(XY+bV<<ZIn^W=QHxr!0-RbZ}Q5~ z&+y<$qG@IrilQ^4c<-Y>;P$Prv-xCA*9Y20kw?v^pRPH+nQ1G9%$C|VEN6*X;}{1R zeIR>RT0WE}Wr5bYB*J(DqDj^K4*NM88+`G{-w3%6DNGZ?{J@Xct z7Gl;&AsB|hvop`FWdkWN4v9FHhLK7sLd>`!)7FZ#P*|0@v8?E)Qs~N7Se@y6S5EaL z5D{W77Z%#cG8Ms)Wx!S$sT8)7M8}lClnFkULgxk&g6#&zE|ylEA>&5KDUm`h{?*oF zjK>Yov>KT$(L1^^l%2_yz_>SVbB*HDpZ<3^JGujdyEH1zJ7LYOU;f^g%hQ^dLIR&~Kud%stm*WQ?JO_fi{b9OBO}cOVKin@~65U+kYfO87 z&BF}UORVysUvbAS)htNfK-=Icgh>wMZ;6dz_0%sW4h&b;Y7Bhvj^xkwS6Q)`U7^gyeMPi7^m! z1a-o<-uplK!o6SNgQtp|j`-ojN7UviF~Y6mo|kXk;o16AjH*#$#6^YgQ&F=vnv;IZ z3{!woCYn^?{K()OK9=@~$|&lp!cPUf!Iw8_2$^NuP%SlEA8~$*$PJYOTV;l^M3Oll z$!&R^4nDDHEk~_EkxEjSh!|x{+?n+Rbjf}d#o(TzAUKZ^#q^#FJhRHx#qBVjMHhW%>bz0NE+(N+P5y<gb`JS^kZG@b~$`zx^vnrTM}C{X2a7H~$xgRR?AY zIloSQdc}zKP;q(X-tjC{uQ#tKj)b9x`?;WO33+90P#vt zoJP)m0!Aq>Uktv8n|B#&HMOj84i^W;C|E9*WS@BOVe|k1AOJ~3 zK~zg^3`a9dO#1(0?#-h$P0RA$-!r|_H|(KmS69z;Bi(?4Ac{c=rWKco!Qmuvh-M`* zL_KOI&pBpA&Cvug!68v2VI7Y-CUJ@Zk2yi*2pkXuL1_>Hq3MQhda7~P9=_=vp7H$g zd{td@HzIcSTD5Ags<*z{_16C0`?>G?x_%dnp=WF)N@V2O_EsW=6(S7;F%Z0=DJ!JT z`>}*31&=85O+B`K2S>K=;`ou~eL zd-@@=SVoTSl$_mrFUL1Nmy-umLY!jlX$n*G$f-Z(*>}902Twf0&XE`J_{onjxD|B; zRSC_=5JY5tuwr}M&}b->ppuFqBqD)PT_TdA_c60XMOFpJkbRxH&{Rdi5POz=!h1<+ zBpYK87X}C;~!7 zI@{wtgdizR!iIp-SqL?*BxepRRbf~hc)F!SRxv}wjmYRWYgw)Wb*)IjvziYmCGu*B zL{k~02zjmG6NigP*9XRpX51Ls&Jtq84=}DgJKKuc3YKjkM!~r~%jP69ov4hyBjT(h zCBx>pq%x7tMgp3EWUv7(peY0~c1%YK9|W$KXjNo*xCm4RB!&p|tC(#tS~8mE17oie zlW9(^7BW(nu)SHaviY!+qQH8GBT|hOw)fXD_^&&wMYF-V(Kg-SGbQ|LW6*VB3lVPH z$fe?ZsG|>w?F!DW!X@LUi;LoUl1L=tsws22a*v0yq@#N=36ONyS#Br07HT*s)^-2Uu>Vf7%Z z?gn-{L(@!=+TvWvCqMNuHk#Ym8r{TVw8xpfkI@hL4Q+j(9_49Q?|Pl>mje^;GpN|Rz(UhIE$7NktC(m6f)w1XVzJq3m_$n zm1osie6&~>@jhkfI36KX=8>kvU&dTfx?(9JQ@Wy>VbJ1 z=$)WwG|I@#yPZdn4rS7Mk`NjCNL?vXfZaWZ))GIGj7Ea05RB`Rw(YahG$j^YV7ZFK zb!y41^E6f7C6)zjY$=ilYXid|3DIJdWM|vpy=PKXD4AH;9tbEY*{Bp{snFyxwo8(t z$j{s%1Q2<@Jvmxodzpisy(Pv#Q3#BV#1xs-g5U)QbCE$TA<*|7Nsuzml z`n86lW})j#ijTO+2PlE)VEhH2&kg_R`>5`I4(8}lgeh`z!2Uj~`|soN|M-8h`?j}b z0g;E}f8`b2{r&%fgD-wQ_Hc>RPZYjO_LmpK$}b+Xo`;IZ%Q&y;QlFy~xvMx&!|6m$ zfPdjPeJfw^4d28se%CAc_*>r$A@X^z_*(w%fA~dC-g__izxp-E(G%V46(i4U6h(QJ zVka*z7~;|$-sRW%%R0xH;8_a(vVqsz3&P<)m*V(odlfIcU)L*&Pi2>QtvD(vVe$!> z-JTCxPj_J)SB4ZI#6)NF!+_+OwGNjw-QZE8!aK{PF$n1?3Ikr!4HmUl_k|R42je42 zMsyQcEdst5XaR-PLXsK0d~}9_JEGQ!s8$aByHSO5uDUctMv=^6Xpw0=M398)x_4!_JY4 zuFDXClpy&)jDbOU7S>^87L`aLI5N(@#pDyZiWD0KF&JD-ECx&4TZHg5rJ*hjtJT25 zduDT=3#B5bM9v34q<&k%=0zV|?uBRR;rW+-7CDBSCFbw8= zeq^MnE9~Hzt-3spv;!dtj&GG5+ks+f>4KoO0q+zsMzo1Immd&ip&)uv%t7-)ChAI1 z8jT$yzK~!9Dfz6n_0V>Km=a~B>4rc|fx6Cn(`9FoBJTus710zBHQvW8z5@0S1{56| zW69>ILZRtxz(<1?fg_^|>mqwI%dGSH`%!wD21+9s6`;nFeiey9BSd~8$CwaWQk6N1 zxG13QpdAvcHZmC*3YE}8GMyA`Op2T(e2u_W9mEsah>L24XSXqSmm2`Mod zDaJ<7yG%?#fDMUpAs87ry-M@}1n2jP>)m1^zlkCYA~BmB#~V!%{e|LqiN`QPdBbrw z?s+-()Cp$q`d!?)bNI!A;?~>PzUM31`Kw>Y13&!zJo5AZo)9ea_rH$^U;A%y2m6Ti zf#7lzf4Y1Ody)B`H8}eG811}b^#Y#GXQkr$fDST;GFuO$n~(9_mwy%a{oXtH@bA8z z<=z2G!25pV4SfBpf1JBt`cfXfoc6*~Gx!UxUhHJL6cli^>&_eN#$Uxa+i1wGLitWdC!>A(;rrRWHiNwK<_NQ4WtCMsnJO?sVj^U ztcD(?B*sXLE|DmzkwL0RH}q>Tx@OsWLTW)IN>gz2&V;^;tPWvR2|8!9%38syZF%rh z@8EOq`f_eO`Z>&J_Y;F6x|TD$AL7niUrOJfpw>Eftq!KX7%(c4 zOhZ*_ZaO|dFnB*=kdDD=9y#$*QW99ZqA)c#@7zVdI*IcuToO2;s4E51FoeW@>rh16 z!BZA6t_?nUyw550N(!{hU~v~DT9j0}K-7Y!guy0y+asjHC67X2gIYgG6iO(R)PQ4q zS`nh;aNgsiM;nEbIUsoGB6BP&l`w_Mdp)zp%ngB}kl2(MoS^GK7g=q&TAo+bdJ+P+ zJ`JlPTMxz~Lq7<*d1SLGX{v;lnZ#3;l1e3lOC+c87KYvvlOh6LpASu?F{B`wcMj2e zVoWHLAup#-4NNDnIhAW4B=imjD+yAt=p4ubZzH7&Bpl8P`ra`vB|<2KkfczuXfqJL z?>(DSpF`XW^8JtnE?7cPC=^{k(7J%qP$H^1~{sH*0H-}x;b zc*~nf{gAJTaO3AamzVy-@8y{{+Th3w2x!L?qEA?z{h8 zJo}kn$Q?J|!-J2!hqha>y>llw?%c)h{zrM_)T0=!kkX-aMzpCYu_6#fKx>dvV6DI? zfe((D5?Ut?=X18F4O^2jvv$F}wMZnD&WJQ);K*jdWGr#Zl5_I~kRj^xc9o&fN#MpX zZX`QLHH9wlgQi^t=1Y$caBBBMl*SNTK~>#I2$FXGNkXtxWy9Xtfod|axv7vkl0uG~ z8dsX8f|ZpVta_GRi;p?9ISD9D&8+L`dP`j@5|O46RHZ-)&9ZYSp^;i+2baZ4qnao@ zrAmmD*r*N3dCndL9D&JLQkrbp7@Vb>=UAxexTdN!K4iaS-#dmri>RakqccC&J4aLG z(BmWoiGY@%q-1asyGo2|!S;5+v5hgrh$9dkI0PX^s-nQzNGAm;X^c{sLNg2&p*7Y< zf=fg%nJoj7z>)2o7_w?%dsLth1R04c5~4&an2aSN2^=-Miyj#V3L~hD!CAq}oS+7rK-oK(KKE*Ea zx<&J1+Rjx*vMJ@lcp-x7Y5bTi=ggJ^rjUq`d7s`}l!{cP#s!DbiAt9&h8%;Wl>!uf z@U$*4L9=QHN?maC)=^F^7Wf$P(P9iV8z9Gm`F_ON$l&s6x>N#@1|B5Q zj_rIdgY9|X;ooC__9%skB$)x>g^HLYFj_GmV88E?QZfvY-~&}zAe5vj5>=@&y1>YU zh@Q==W^b`Viik`do0FQ&(Uidk9zDB@P=TgyD3oMlTre6{oY`w}%fO=Zs7exi0XiZ} zkDDi?jEt)a8!}4FB*$X0$L92AQd-gX=jdFAR-Pi&IGb>T$LNIAu<8Zp4kKHelFhNC zDW{y-YiWmwGKv%f)&^YgbT%>`DQZ=7uqV*c(Tp|w2aZ)YFlp9Zm-UQFfiYQax(I=y zgj>WBb8%3SuSMUv$_M>1-gm9Qqra!`YapeJL=+l+F86 zV1blMl8?v&wzu*GK*@j`5^YaT1L=DfZNOWBsaABIqpk&ZkoW}Cx}cANp&OWa7>yFQ z9Iqh?#-&0KS+M!n6q?c$%$Eb!Mx=(O zQWPo+xUTJEOkgF<&6rh`6fRuVdq@JKpj47d=OTEdQ5PN@l@{!G9%UpOWiF0~UASns znARi9Tqqr$g{pBkD7Z9pCXiJoLJsMxEQ^ zuJ8WGJoE4W&phz6KgHR5-%E4boxI>*yqbG{;aB*TyPiq2v(1bD*$>g&aGW>(^;huF z+uw#A;7kAa@8_le{9p1pU-?yh;;nDy#eeVH(N)DS{Ee^Uf%krZ0Q~lkzKZ|#o$ujm zfAEL+!(V?rd#BFkLqmc#!elbyZ~x@a@ZzuedVcO7e>We!_rpAIoV&DZqT8<0-CY%Z z_GAzMuH>+)i^rEpsWm|qGYg^jb=pj3ME>) zVPM`_im}WQMr~m59<3CUX+d+Opj~>Fs}>NQ9(Vw2tIqV`4B`FE`A#NZR&!9lR}L!gwods14`E(cO{6op315yKEUSS<)z z(+vXeJxOM+rI8Y=6YVPRK6Rn#yPoAiWb25e9!njN%2+RieqC9;4>zOOO`LJTAk@*%$Ma4zEpLzIlh z3fJW^Pe_SI7c7^N;0Ly*25BNTT9k=|A!1!XiFNSza6KO*(3^t!_y~gyL>DhGYc4nU zH%78i2vW=)<4t2lSXak0{yqtk{+wI); zm4BJ{{_qd*(3{?dEI}9WzMuIw*)YAo&*rVS@$A3y3O?}5|Cz_%_W|l66K|}CxBlB7 z=as+oYux_%FW}sXx1fLqSb6y7AN*ln_Ba0)KlZo3g}1%_H@LI95(a)rLA!i(dL2Hh zyh^uoH44tOZDH3c6c!`4F{4Cfv5>H+fKU1R3Q!R?}Nk+11Jxcu_p)l?q z_H0cwN+rs|FmHPX7qLr+4Hl(xT#_3C0zqAhj4LxrQkI%(oS3Z^ z6jfrYEU*arVLkG5IcPWFDYgVYWqjLYS}^#W>M*Jb)D4N{uBT}l5(TzzIdSH3>Z0Pv z)&|FpzJL>_-%mRn(hdiB0>`R`X`?XZghFecabv;-&)g;syCusI85zw~8#*NkDPjsi zO~G<0*xNs(8cBrE>>hMfg=S;3AOy#12n=nal8UbP)Rp1LR*iKDF9srk&JAeOP-www z*%Ol{#Ym}i#;R#WVG=@vUnPRgsI??i_M@)^WvwvM(k&AQWnwi9*kK_0#B3Rvjtnm3 z;xZZ6v@4JIn#ok4LZa^j+CZ~mz=IKqH{@dMo#4b-%g$7jlES;hs1yhU%PwmG zoV64t0@=swU1EQk5pc`iv*-nigtvi>4MnXa^SP(Dj%uViy4_sgt}!UXqL}1J7#FTe ztWgqbEvdA?hRD)JN+m8hI|{WPrD}m#7s_cVIP7yS)&+iQ0v{8z!BaVfyUGUV$r_f6 zq2d`s;}J?KM-onTJkN-$AV44xZIcA@{ zKSOurT4~x_-udbuBLTO)?2Bo3b~yOdgTz42Z3DD|gGV0D9nr?d6A#x2H*Jmh+He0( z?tR-^dDH8EgHZuRy1J)OrmGwGuU9;;cHI@Q0Io8M6_*lpE*`B8z{^Yqj6d{eTo9fT zk>;{}=#!cEpDNYndeK%_E2J^zL(l&Rh0!{Xbs7~T)~&DsY|wO_XEh9LPseDbnbs9X zT6(`iYek_nBIPKd5C!vgAovWZ_12-ZM9B&t71mn1)}oYWJOX#ja`qIA$C-Mfq(rJ5 z0pz{qzK8B5B3ZO&sLM^3tJB0C*F#Vj-yk7w;2&R430|cOiGcF)nKs$%x0Ex z)zdU3#o7;TZJ?@Q-mP$6QI!=!MUqf-RZ;&bca52^JZ;yZbs}2HgO5A_;ZEAtlEeOMYapHLqw|pQjn5B>yRVB zB*Z9L^$H&%L&z3@O;Z_qD_L|FVnn2vcZgDha9{DtwXu;SBB+&W9(&i%Q*8Yo13wocJ^^tKQNF+8($tfx5 zhLG(72|5>PU1W*mXkh)Hef=)udJkJwfvhUrxm`pE7YTR-aoO{!pZi&&_Z)rMUt;IW z?m?9m?a33IeA}D(z^i@;xdz3CuD@V0IX|+UY*l!G7!X3BjJc#+iwT;I&1}SO+e?a5 zQ#aiETW{nYzxA6~2~~ny)Dy2Su2B>($G|;V@s!ut$z6_%i&s;rUN(xADSI2gv4Gcn z7NV)1N|$(v0P8a#+FUb=N?d(RfAPHuYx>Rk!YH0b^^H`5MIV?>GJ(d$z^WUV&l1OX zwisNXk~$Z{0)!kuBvMR_>k^3A08&a0XC1XxI2-aqEGn$+X=+c50+V3e7;f0nj2md@ ziP_vEN=e^Ztc?_+S)tgr1JGm25+k$EuU`$U7M`*eR8pX;5+wz# zwOL44DpE=;mzGL-y1u0z^|&r4*gFUJKlA{1JmZDTx;<{a=`WJzj&3C6OsnYJ&)hg?218Xll?Bu$0n|<(pKKg_I8|5vx zA(|1@Ew^&#w|xiC{fGYxr{Dc9`u#mrQBiGfWpMOb@hX+zoB!Xp^O0ZvMIQK_-{SD$ zPjSnOzKGGp(04AMyd8YuH+(a0=s9!$eQ5avO-F0Zhu-=YDj^sFZG!SiXf{Gzy&#IG zih{dNfejaZeo0Zh%+8U34$TGqiF<6=WyPkO++D>)|#>`Fi4i2!v_IL;zGo_46*hh;ge-D(xf2K z+Mp^)QI&KSPVcqo05@!w7^U$sFexKGCWO)?G|mca=#eV0v0?CaqU|zJKxxfmXa5+b zM!fs|Z$Os?WmQmBchc{Eltzv?+=~>eL^%Sb1fz1q;d~B7AST7C3s@&8iooDt+7xUw zCB5@hW$v)g9S+$OjiPHkMg_Dscq>@+mK=4ga2g8ZsZ2h|c&~EqpaE|+2m2ABJjZt$ zcF%R79JX6wy{FKDs*;QvMQt=Oc?#oL^%1QMAta1Sj4MNo3F}<`9?_9=2bRNGPe_T; z)Ibs}=AOw`L0KsJKGJ)O6p2d1W4jI+Lk=PK0i!fhNQO?*)Pl`P!?JT6u2x7b80!*6 zLa4;C?HVB>tKNfgxM*{fR1!#$P$sKvod+L0Mk*MR_}%~jAOJ~3K~%IBbgcui9><1~ z-h0j+I8sbBBST#m)Kz|e%-ezG%3%jVslX^ftrYz-5&$%>WuBn3fW`HvKJz^&T=MY{+FQtDO?9i!6rRSuSkEhlo*du6qJ7 zo|%7wGFU_mpH@-4_#;}_eBp~|?tTuZfAv2T2Y2CgFA@|RHMjotZ>BwUl2gC)W+Jfv zp^q^C#Qhw9`9~Pvax2S6K7|l)%a^~Lhu`!@`ZnPcyy%~N7dLup5UXe z|5d)^`+k5EAN&CC|E2##6q1*J=lAfEZ+j)b|DXOZ&V2kKbdk;eF~GCF=*9faSG^kV z9KZXk|CK^zE5rqu!R7u#aT&?xGL`C+s!yK;0&t=DrAv#Vx{AkN}TikeT#My(#SuV~|7aQDt z+l$%Rx}6Vv>`in-k3}=O>27X1b|)uJ{Rs~}{zptlfvU7@Zr;jPb33cm30A`j2OQbF zgHb)AQ%fq{G8#>Z(Xc;1#p#2S1lO@WYAAGp8+vAkmZk}eOF_3x^ukhTMG`%KGi7;(gsM9@uVS$fwl`-j50(@6VW;&+Nu)nxLtE_ z7-(AoQQ^F!4W~IieHMEMr+Dr&@4*fSw8K6!2~^U^kPAVI*_L6nAR@5AVG6;j_p~d) z(aoCKFyLGukdQiyVq{2|^+`1*&!V$vt=QPm3 zHsWl;ThB(LS=q=C1`ZAbg^Ea(qonF0TVc?OdF#>2AiSU(G8|yk6b#Em-)CeRO4GNN zvPuN&S;fF=mIIl$j+P)I5l`19T$Bt0B(E8d6h&EJ`+yrPN-BaA^fux=Y)u+M%!ew0 zz=wpp78XfXk&Z@^-bPkkVA2?DOtihFP%@+W()!@wJcA6FN}-h?Mv0V)!9vq$ z#*N@`?l`wUppC$F;1PHW_{ex{NZzx*-!rU(k54>y9VA>#V3Wu%5)&&QS-B@3B1Q_H zyHn7*$Yv?&Tx4M*Mha2_8_yg6VF+;8Cpz!BVU*{FF2Ze_hS{(#q9UJ>l2TN@N2YMq zk!iZhIQJ6kNPzN|9ghF~?P{VH$x2j7KR3v$jQ?#jAmytU2pU>^xgfyw0*7jX@n z#^wIKt3Uv*D4y4Y0IcuXh4`s-nGolqqN~E?$tuq;)?vC-q+56epsxWoWSW84~nRgGe=uaZlfU5FH@#Mi{>@8=AsJP+i7jR@c z#%Rax{4_>ctnaBuJKVT&Cou+=?Mdc~v#eGYXFKYqCdtHIx4(oGJwy9A&Mn!RHZ;a_ zbmuNAHD>qVBqvWl%vjgNB(dQDWWt5S=H~63JpCAtKK>|mQL<5Q&_#=Dd**|~=z<_T z`v;C#MUx*p0X_H`^4^1+eHR(L z$E8f;I+!_x(reylz!V^*XQQbYH#N1kEIZFINVL*;@0g$4W2{H)o_vHV9pmtDV6i;R z;DnLDR8UMKrBW;o2I?|v8jM!Blt^A=KzDBuNz?ZNYc0+vlnhV_G@9iK=JQBB5j^9z znwySQw0%!!10hO`)Ew0bJM>I9N<=;rcHx&0^8@9DJ`-X$EQee0z!c& zU3*Q{>ExGvCIV7)|@f^k#Ow+`wefM*?{Z+4F`m%d?;JaVR>SG^y z;%i?&72W}Ti#AG@S)fI2*crwyI=X8 z-1sG5%IfSH-uI*bf?-!ebx$aE4D` zR1~WM-uqvEjd%X?ui?q6zVp1&%OT(Lve>Ar1r=X&pU9JRis?!k&gJwQag9Q$QihB_ z6yU@0vrrh*m4*CIi+Fpo(BjMQ-%}CsobMQ)Zt;z(20CleS~9LC^ur3T_7K4!tBA0X z)^_yW3TIDI>Ix|g-5?p2IZ+^rNLdP;JLJ^vhv^4PRV0J}jX-k0iU<`seQuAcDey#Q zi;hwWHa9#nSwavTIW}h5Kg=>J&YW4%G%|Op*5kckJTe%WNGULCHu>_Gypl>Q4(Gc( zw)=7R<|i>?i*`6bNRPD^*(&r(QWgjd3M|10y3to8j1IZJh|t5NuYE5)-q% z0q-JBEmmyZ>|IT1pGk7CiAE`^t#t3$IEnVl? zm=-jnQBGPZ0=lX)HAp8yjA$c~oywueHsDeQH|!q_jBACEiP_Q;lc1^_`jx}WKv7Dj zO+{rqhqEF3C|xdyN+gaRDX-lz1~TSNMvoFAi&1!@z}!4h2q7>^QWuKdmB%GPZE}Zc z!+A(RVq_9iv&*fcPjam3IA@>7spSqXz_CWqdd)$fPy#TDk)0!gBV22Txc(ZFwd{QR zcXQ-h{|@@tam>yQ=&ddKhaTjC@Ax~M{q_HH0fOr1bGk<#Ar6-0;gO$z9fyDX0d~If zt0``{f%dUSc>Fj2JLf+5QB<}5+UE=Y=tq8(5B|iDV!P}!OftjC&p)h{%pS}K-}3)u z4^5uLtbcudO?m=0t|cV34!&LQ7jF|!>};PZ&E|SV@nZA)<*#-5uZ4?uisDM6|J9Ij zb%HO}@L~IBTo^Csp7NRP5-$frh-)N^h^IJ)m1`iphrjP38n7vmw4`nnLz0ZfV{YH6@V;kZ7c6>*^ZC@~ z9Gut<94;->O^p)?Ka_Nx<@V!aMmiE=$lO$6i0eqDZg5#)UrBDhQ?OWgM#YFxZRm$N zMk~BuqSb^^wJw?}GWZ^XM|eqXG`$lDEl5Pd+N5ugEL$)puZ?1im|A3Lx{=@`g$Zm- z42wR{^@+CiOd3s9jEKpz>K!Qxws)qOwx??cj*O=G7%+uk)ReUCK-UI_He!PZEvOoS zNT79MJOaF984YdgQB}5i_?XAG3CY2}WwGBQm84q*f?!6%f8XeAM7Qph7-m2$3ViXgP& z%&aANh1810JTRIBQW69gDXRSM&{|;I$o>k-k;MCK7g@{(qK8=slrCjR z5DL`FLlQLCBH!5a*t8hXe#oAvn7twhs1zI<=`0aej-7K4Guhv#)LTrp?!=}XQxavu z3b?60%~$OF78Mpf=KV0xOUi<_~ zYXwa>*k}2kcVTY28BvsUANvSr@BI&~KJp2y$eNr7 z6%%{!{sYeb?jK~^2tbkZ5#!pDA|;qAcL%y!3vf~{CMjMNa4g9C3Y`_UVI5F>J`E&Z zREXlb>pCCktP>oQnKJX~Al|O%nw|oD{EBNXwz;g~=NA{mi*p*)McIua!Ep&+uHo%} zMnW8UQRgh4f_>tt6vQjWr`Pa3K9#QX{14~yeR#S@sl(vuQzA&uLA%1ZoOplA?h|ZQ zZ|)qa7;N6&8etfsqw6$M3HDD6cmhR{$4uSeDC$IXfx5{jzp{eDD5O+`5V6j)x8EU9 z?CjLU>R7< zZD84YypNb5xuKpA`os_&qgvqyLEAY}l-Sl%l$x?G7=mN4mTDx~n!>PZ(S>2&w#*hY z+EwJ{8=u2%H@}#EILTvYK8X*Bq4T&wQq(XWXIskrFrbRabebqCfp?Ko7L?;iJ2;$A zq*BsUg5?l1`c6s8qM%X&k^`v`QX-Tj2Ep0cEN3;AiXrwKu6pXmP}h?2hM{zca;Kno z9v3V|N(xh;Rb*O0+XptLhGm;A5kdrv7BscU(*rNr+x2W6krajE;9T}1>LTG?0IBdc zv6@>LscShY{THSqKKXsop={tec!J! zTI_PN*yg>*Ud24!K_Mj8I&9~uQ^(oUp45IG`~4R8ow{{)rZl-<4VQn6ko_| z+;>we7_Ih^E)o=19Loi{V_UxW51GCFf4ZPwP2_G44M~Hn*U*6V@2Pc>ys)Db`E`_e zqTr=&+c$f`?{HqKvn5j90#oaAv)(Sd7cDPC>Fdex%Hm0}!m zJ=W?)h3A?e@yqzB7w;hraF>Mp1e{8LHiZ$cp11j@GVfnye0sUX+Lt-?}e{TvsLP<&kmD*Z= z7}pE#xH(a2N2vvN@GRDLlf_Cxk{Bg&exHi$Y>e2Qw;b$yO05ww(scv-oo5v+H|*4S zA7~1LR)&4+@k4|fgcdnr!UxJCcQT8E0b>M{QAJfc>N?WfU62(`bp-DZP+F3Rbc4h6 zib*wLbD~-F3yjVo(OrzV&{G$hx{#SPWD`;r2x%C+#dn^nPBfDe=Ol~XBFI4VZWvh3 z{(t7)tVyo)PVf7@+gWp|9Y6!NeG`Sk z3P+5_k|mAIn3xfV!+mR#y#fuO0o0b2%UR#e7pDqHBnsVV&Una-Ky(#4Gpn*H@jmDO z{GX*mCK8FqCLSLHtIA@X1QAG5=xmGDic}|953RMNGGL>|sEk!@AxM-O8bHpf6?GT! z5sFfR6bLLvE6kOIfWV}Js)|I0{>M@2u};wUfixFrA&CxT4CIAED_9(Q(gLisNHJJ} zib4mr_nu6J}RkLwjmOQeS04j?Y&U}X@4ITVF@wklOb2)-xj<`|?mzLe0`p7N`G_~X^`XL`;6y%yzm?z$ETF8;_?SX zo-9U|>j1n4a2KCnd>qz*GVo*(a#))hAAzQLcIwTh07Z(A@iFoVWyR0PPz@WP_^6jL zUb1^!14w`?5`IU+p@m;}fJz1Itd&Iny@BG#+^6iuwz+RmuvElumVcC|n$PqpfpF9P$bCCwsD9Z54ok{QmBA83!JviMX|giO&hd?wj0!TCNXS}4Zee>v1nBhykl#e61zxMMJnG@P9Zmv5Cc9q z+Ro!`N5oN#6fxGrg@!T6RME7ahyxAPJdkCBjQ{xT9gNv#TpqABDUo8#?Ce8O0vS_$ zuQ==$Y)uS%dt+8jJJecbnrH(?c=A%?T*|5qD5V&su&691Q6xrkJnN8J;PEt-qiTDy z)KF|0Tp#Ib2x*EGLl>m-lGQv=lp3KR(;C|cCL@I+rL!GESfVK;4UkIoY&E}^YkwDL^K;o_`yJw`Y}6xa?zh#)ni zTp;i)mvB7yjLsWEgcK;LkZSN>hA@QK53eIdc<7scNDE3Oh0GdwVals}ihpL#ASCP%@HU{RVAN zAeOvsZ}Yz|KF`4eOA)VgsIGE%{3fH^z~YR&9g0c)^Bg?la!W^i#(y^-8rB{VH+~*b ze0=oW6Ck)gJ@Oa~FDA_kV2R>s(D@|ezPQAWacQ;Gvq13@+r}nEC@=9aJ`oRhiAuEx zUX$>FgkSucVw5f5OY(7_<+G^H=LX3Q@8ieisXjMNyGBWGw=mZOmHL|m#%Uo)gr;pH zT3EWiK_&@#>X?)X+oKUDiw3DYiPSKTEaosj?YVlbATa?O!;ln`ND|>uaftPb7@E38 z8-rm*VOkftLFZ?vNG*Z6}#-9q`I)zt4An^nau3n&1QI zlKT%dG3*dp$=wG(DcVR}?;#mX<}yN(Xc7|{$s%M58U z6b@&JCYKp~>_}6^$=u;%#3_Ldfv%0r77)S-eqXRP*`jJHf*Mn`6@-pNXY}4-T|%KH z62Uaf&`NN&sOUpPD3C%?Bmy5StED6`WPJ9m#@b$v^!2V83Wd{n;`9NwEQVfis>m^YP!06r3 zJYnr{hLz(%Bhj@WL!cZPd<16$Wj1(DS9L@gNr*7rkyOio)0!kTIP2&;NAM95C9w~T zcMPkgC*m280*TbrZ4WAd8UhN+QeqVJox*4kY5;3@UZbUy#9GPmECP;VqA1dYTub^k z4t<)vBN8dbLqwiQhAv4T2A^kDL*EU1cORZHG5+cQ20!_8_|*?UcQvVS#MJPmx8LRW zAKqs~KokPeTTb*9e*We^CDt8TF@hw=Nl8r1Bfua+Y2at|5BNp@H#AiAqmF0-Th8;< z@gGwp3Y0>1bJA`(q>P9sQ%Lv}li)=g!sY|xuNfNf1P*V2pj@L~F97q2aPu`l*-V<* zoY+22K=Vl<0G9!t_!v+WT;9zn)_ja=gH~1XNsnV8;L8f`1X%qV2fRMFt1Lbt;*IA3 zF`kj7`l-S7Sb9yo#+jl>66&ryw+2|eh1tAeTo_#RcpLBniacRk z4aqO#+>qsxs_U3nOSZ-d(p##w!}?*bsI(waFfL1cNI01->3T)wNsm>E zh~(a#4-le6rzJOUe2&@TAs^lU4u=otT)*-XufKGiy0N@}_Z}y+IluVm`+RuTP*uk) ztCr&A`&>Ub;NGdp>x_qwNus!M7-|3M$ zV9by@6P)67;W&6fVNyw+nL)RT*1LLf<{qAXLo_70B6HcAI`mlU(=7l^-^oa zC#Bi&>Tf~Ta3|IAWDOX8t2@3t3*YXrYM~vMWCsB5}h#JmPBC*PGICf zExx!r=4{^3b{^{jA@)QJi`HYJr)`(4&LUwoLRx{=!$Iz2g0*%~l8+{IRn6?^9^vYWv9LecmxLP3wqn*V#|CPDRO}_B~B$&T}PCPs62ZwC}Oa5acJ-`rD7x^E?P{k z2t715(piVrk}Q)*Zpgcjr@fe4CvAqhb<8V6KVSZj&Ofz%jdD00a(SadEK zjZ>ltxB%9Aw1VYK(AdE`QW!~|YLpBVTG3h0a^YCqcOX6ET}2cZf=@y10)~jxnyL*5 zhFy1O1EW-u=7ZD`X<*d(S9`G?!$_AQZY3 z7)6A;m!=DT!UDtu@$zf@>v6`vo*nV(TZg=GqM6>lLkPENw+#A!_$nvaE`RZ@ zIq!XFX@?vs)F3@|9P=WRT@u<|8Cn>zJHf3C>QZLk~7s^yvi-Wsl>U)+4QEar<%S-%t zPXz&pXHd771O=!|_KO$5@Kj`6974wb#K7GS>c208|EEc``55E=r}aHLWLa=I~P>R*6rCKS zC-Vh92C_oZcNW_#ma9Qb;=3hDc!|aRBXVtsID{E|W3_7-k(1;SqdX=p>3YxU@gZ5B zuybXf>(_smkB;BMamcJaBw9n1$4HT|JszV(!FW93*8A^59*KSAWYx02ld``xMaIag zu30Q=%5s~kZJ3=b*)oEwqnzWe!N`Ppn{oF{vudX(b&Vo)d%aW&|NA6HU`Oq*gRtBzi~J0t~&2$HxnrR-vV#t3f6M<=W<; zO+w=YjdRco3azNSmegnxqlv-eI)^MIMFt{zoRdt;l(V`+n3lAVBwC^fIBQ4?4Z?GL z(vxRHp6YzjlO!7Nq3wqY9=#f3_y~&S%8`|V5CfteE{cp0tX6Jl@@PFOiKqlJr3dj= z7SR%{bNK!leT?c{BB(V?OwCwU^hP1Iffrxn;H?=~Z+X0QI2s~>{={$t$1xFFASZr@Wh-qI|)g`8uz?{(GoIB80@9+@bi%Uy#&2E*%6N zl5-ouIT&1k<#V67pOS*TjFR01$hZNPPgp$J*fp;2B-akyumLdfk~%4MiOO;_4dzmx z;wO0-dAgn6akh#3)hfX6DEPKt+uMH135ZL8>L~!-xF8VcS0&&B(N; zYbDN07WIm*2Pr&fm1AqF8K;W6GAx&l)pE&X{4&>Xe3`@)Y)|fU_V5qG& zBcP1*e&{s3^I;2U`o>YM9&qETW3Ni=mmWSJ($;G?C;H33V#ig<4ccv1tSG{uZls?O8YHPS(vD}oPX3ACL> z2!nT$X4RACiWmh%hwD8_mY|FzE%dPGocGu^A$UQE!yYuaAwM=E$VLpWa~TL8wstiE z$Kn*`XG5)@NhDq>s;0vu(IhP9J$)gFMp5L3y{SRUp1Sh%&XXpd`-dI*7`C@T_+dxb zT8%#sCAYn1JT`=0qP0M$4%-f(9?_i595H%|u|k_cJsYEh5NKMcY-B#OXroBvKpm$e z5OH`dt9ck`*i;ileCFC`@a9RF>J?k^jJX~}tWG+Tci$t~(WHgJl#0goyuUNzdk+>= z$8%C0$#ft|0!jpW+cBONy!yFs@>2H)1lwV<3~AC~X)GeXZHRyUuNeREKcLKcY44_g zFK$#zeG(qV$JUI?#5hlgZ=MB?@o6t5&q>9KO&~m;$FmCQH*THsU$0|13AU-ie zm1kH$)_^XqPnY3oDpg$qn3^Z|jOzS?^kKduqEe_ zbWik7ZtiB|)34WGVpCCT&%62if@j3Wod?Os`0J~1|GsWAD2iOryO!N?!fu&Rdqr&< zR$YhE1-S^cy`yS6(j3}mC^GJQ&us2E*v>EsMB$J^lbVc=7AyMR^WwFyGu?WbC^O1( z%yhEF%~xKdUY_#9?|h3q$v{9|FHy>1a*ZO;+kiY*&8?2_v$H*7cXx*`fBv8F(_j6c zyl{}PyOR@xB26N*<(#{VW8Pc6&-H^h5z{eypZy#vIChL6HVdk%r5R}!GUe^tGq$wj zi!a^arVqS#G$Y6Yp$vI4%XuL9z|L+#W)!nCOC*vclGLOi zEXRkIveax(6TB0wsve;ui5g7!!78+jOo|dMz)6kB1ophF8X*`JV?yqj&FWzw2@PeQ zF*OCJCo9@MBBa53(5XRdP)0BwDHsXrDi9)MV?)<^%BiJD6ReA5g@DczgC^IC)Ck&M zP%RuW29om*zbG`y1Qus4GD$$gViw7?U{Xq42+S89eN=S4C(jM5#-W5H9SIg^fxd^) zIFe;UxkFtCgpiaY$!g*08b#knlGKytf)E70m&}_;S_qs6ohYIgw6$kB1C#dbT}v(p z#&|&y3Yf z{#gTiC7=Dq8yF=pMT!vFqa>XeBHe@AG~fD{l>hSoV7s?NoAYKz;l|!;y^849nFx7? zIOlmD_beceA7csGoKP-|{~!2aKUb_9-Fezys5Vrh;@nGU)*g4Ux4f{L#Lb;(-1uHL ztQ$|XYs9B_jGOmS8)BRe_=M7?MX+o{=sn9?@+`&e z`D^tXJ6E;&UW=DsSp2r!UbvPZ<&ZdHgCHtN=X+XbQ6fd_g!$PVRb=Fa;q0iR>m2)6 zAx4Q#HJ!7VG$BnBs@769OLS@R^MH3tcDHv~RuQ9e60NvXbkD`X7)@_b@vzF!i49WWhVPj`(OMX?u^q^N@qBF?qI)s~n>4$+8p` z7Nqj$1e>a zfRF*N1SfOHBp;J$_~>+jQ<7E+DjCq3Vz!*qHiGTxO|BhGIG(-BSKj>ZaMp4E{vp0| zm{d|%jP{mOm|WvU#EF{8Sg_^C9L+lffz_EMONSxo z%-UhE$PnY!RW+QKO8CUm*$7ocDnV0u$}D5P=t)zJNrx5{V+>8Jhol=5NfXK0q9e}* zS{dppQ04-y4c51u9($InNRqZ}?M0GOkm(GxA#^=LDv}hkOp<29DS3Pnu$`jo2Bos? zB0A9|dT3U0UO*ersi3bNy$uKkkayP8tez1f-n-$@jKGA7z2&!g=>JEOd<;nRfBld7 z@bDhKZ^^g!neJc3sD$zxDR*oXiA(6#d%%CR@O1@~ z^E<5X^VB6fzI7m42P+jf?!Wo*+GE#uqfY@I8x{?o1VYI(CQ32bFW!{!)^kpc0r)|H zw*!1u4wKk=T98^F+Sjf?3#E_D|T`y~2AR95Eej5okEL{wht~a(eg?H}|h_?aE86mM8R8!|u4C z?m7@XT1j?_f}j5E2TZQr;0s^+9S%?LaPRPYT-l#;B^kld;GbJAI=qbRUo~{$7XRtH zx7eM$!9V)OpAvn|^=mtvHj(3bH3ULS&8lumjG)L2b>m4yPm;aI$#IV#DSTYfI>*T5 z+&{InUC;IiiY(BzJ-gX9+E3WZ5@eUs)eDH0Mb&fnut$W5N}(%ExI+jMZ4$Cvv0OFuR$;}^ z8<^+Nc0GOVi2l6tOKO&LhwVJ0QA*!;EN2~)ZOzu$P`5+xUzTW$3Zzmo8ChZs)D4Ua zMV4q})zkHXsp(ua#M(6UYhdA{L-Sd5Xt-pr_;I3~_z53BqU_Fr<|M%P&UbWMV(Y)i$9SN7>$ z$EvOwB_lrb+EpGt{3WaEC8R1Dl?hVjJUm|U!NXgON4wno%#?7bB!>NR%Ul z6}>w_3c;`L-bIQbGH==SgU9YX8@jO`g(ESN(=*F-+u)sJ)j5xs<};)j%k~gaWWJy2cgkMqfoT1rSBqI4kf-#(_@U} z?5wA0Ab3Snd$y;7y-7iqM%tzu!W~?oZX6O#TSH>RdH?GW0=}#|hOL#RX@~DwsYsS* zLwL>Ok8BbmCFQv$Jd1zoJpb;hZ9P7>zOx5Bu}y zj?5Q<(MZ#GfyG%MO+XT8R-PCK!@krS?>!O8XiLylJwi!T7nsk6vhFmO2qNBs($4_K zss*hEa74ltd5`_K{sj+JiM;Xqs4PdGH*N?a9#e^7NIl1c_ny`5pJH$Q41auw_VzDv zci$!+-9^qGlGZIF0TT_|8BFEyyRhenv0np0#nX)so0J#NNv(=cQkp&w1^XP}_q@+} z0g^`n{yM^&YM@qCeC#27^l^ObE%a-^b^%I$tv+fKSTE9S!rJp(P_K_h$Bq4+`WR4D z>r?Cotto&nD)>wH{6d_+3GjOoUKNjlKW>2iI@mp;jn_p^8$c&71IK4gj~n#ux@bzQ zF%so(37@K^;r_#xB2`TH4CBJ!yDk+-p3%cZ>V?j#(@!MkPe+NOmVk1H03n#cEE|YSMg4 zA|y@cNXnFD-BYhT62mXwdW+F0XMW2wzAjn$o+J;n&fz+B-kM;^O^S#C?=6e!7O%hb zbxvoe{PmCijOq9lL?7`o!RUf04AI{w&t|l(qO$=h^P}Lo`+Yi{DNIv(OKW1*uS2%TLpq2>;DT9J7k<+V{7Xg@1A`d7Zt4^e294}IXP{xPN1b?*>q&NB+nIT zrkF1}e2C;(M%(oGu_Q?~N(hzH;>k{U^(1kFk!y`@`O(($l6EHX)* zLEU?7KbZcB0+}d^EyZ{gQE1u*f)vCq4$-E$B+1RW_cCB)WVEFbLa>-wl=ftW#EMA0 z3eN^cbKVdkB}_}We)QMazxrQkreDEMK8s2Vg37>k2qLkaBYZ_@=7{A-NVlZFzvATQ zbKI;UaTQsJ&nJ8Az-YgO@n`zb1*&!2(SPB zS%mL+_}aNQa2*KOY0-7MQ>_8X`u)S&9!&~g@J%gAK75m6tnSTDA|kP3B|^w7@q{mO=a?L)1Gmf zmn1JFr02Ur+rn&KVUh%=B*9ve%+R}@wu{(yh#~WS2#QuwlO~?dMvjkLjMR*ah>nKY ztfA@P=1Xs~zw=dob$`zMqa(&9a&5Py=_~`2V2Nj=C$bwnoH2mMOYUQFRV&B3Yr>+y4?-{u;mh;JbWu|Hq6c zuaISiJQ*<=zr?-6J2Z6-USexOImw0#fZ*v|V0$~Et~?kJX+qn#MAwrQhQth$QJEQ5 zRmc974C?~byrQZD+9+mc@8SBFkSb+odxzO-$!ghib`sg27No}Ey=Ssz=uAY$gcvQ} z2eM2OtRMtWnh6#&M|D;CX!_W86$lk2jN@~0gb@X)dHD9Rt}y%&NjX=t0h;OP6 zj2wVbsi8OU<{reO_c=YfMf<=E=>X^H+fhIafuX-Tpa>`dS9aiyKZ5!moc;u44W%CT zG-mApb8Cm1SflgYrnhd5Mpc{2%=o12{!=+R#HX7WHxW}j$FwLu>3Ppzi;M7WH`F>^ zmuuj)xhGr$L%lXZ`gLk^Bgp)+$x^R*^q#UttWAT8%O}W-=hPQ!)pH;=0&Yr}1z0}k z@8bUr@HGk7#AET$dLV-Q7@&JZtzPU7*Ixf+^ylq@gt4^FYQzy`_IPKLD(Z5&z!(o|x03{C4*}ehxRg%h~BEosIM>&$a6rxeTm)q+eA?EwI+(yu>6K zZRc3jEmh}fy+VnAR5^W2SuHBcxn_DjLn#BM$0*J0q-VKs7-|mc#dd#@_x7 zZoIfl?<9Zl)o=3f@NKpyHJ^R?A8|TA^AcRDkgsO8a7Cl)m>78S1E7E-UecpcW zNBH3B{QD>^`SR<3N}i7R;NCmL=$Mp}NoqJf3YgRld7x2H>V(mD;P9-Yx0Xb~ORro* zCZ3bkicF;V09^;cwv?%2ZifSSG#(OXI(tTIw|L>|YaHxp-g^J%9G^VoY*7-Up(sHs z!OoQtT?fmmXH*Ev+^`xA|BAIvSS~GH8*yHcW|}NbIa{>MPaJC3&{Ts0*~cXaN$3?# z)3d#22r&#M3SnqhH9FBChpD|7Yh3TKE%d#_&pozt6qzDU1tyCqC5bW;eIQx~QL;P@ z!@oHt5pt-03Q-X~jMEf7vgjZ=nY9Q4+6dB8qO`#4K;Kx>T#*zC*D{nN3x^93MZ_zp zt06Q#kph!xni_-(Bxz(dkMy%Z3Ike69LC*gu3j--UbM z2j4vwUR=oO#oAQlt?JPojlp2zvR}07cx87nj8crQ; zByAV@!pnb5p1#5le)exDi<|83j#(_;AqLNK+2Y&C_Etfv9Lu>o@1}H=MT#yZTT@5t zTFN|E9Y-B2vb|liE4bWa#nrZb%$z+dyIxOs1H1Egu~@l0?%s78iyI zHH6_5D7FkCK->1{#4{;U(t{x@wzra54wNS4WgI!*^m zj$qii_mv|&3m8|;`Hu0NPQBPSW(L+$-%xVRT)jrcU7WK%3}MS54q*YG{ipE4*WiP{ zf}^(vbQWuexL@-vUQl=!LJ@I($oqAP{`vReH$GqAJAN!EK7%WLp1tCxdU5@U*KHu5 zMyIg}o`>o3GD1Zn)mcxFy2Z~D7K4) zlaq$iqXk(qB_q3eI+`S7T^1*3jl6o>J z7#Ab_qGDAKQ<_O~QWe-Qb7l|DNKK&Ydz8)zVXzyxAgJ#&v{G~M($L>0qC%yPlt7*- zPG%O5XM4M3E6w@IFCX&Y_P-;|9a~#d_V-`o=kI)nzV9fLDX+eAz=OkMmJ3H}B$J7u zvv73S;6p-U6v2hzJ*0Df^s9fv!`XX;7`buvOT2pHn>;xDA*wv0cY(%5j0lKWBSc*a_@yOq+`k=}ZyJ1NH}9jAvq z;vfMfv8^LPv2|cDILkrYNO|!O>K(m<7gL5}_hx zrZ8IxZ4=SbAWKQ_0;92@sbF^84?*AB;fWX}s4Gi3hV5-lT}gzCL~U5iJtwDu&;}Nj zBg+l){1AyQ60Afg65#{&*-%tG)}9z0`9wT>VpQtMsqq3R^*P0=&y_n$u2G3=B95>Y znROv@@D7qOy#CMN+Be|C{|qN@gY6$reUAWfgI0Y4059>HJ@TQ2wbI*9O3C@8$ud6e zb&Q{4XZUv&>qs#KR{tjlf20Qb*^3SP#yN%ggdk?^XK+Ek>hlYgb?@P(#bYxZ0r6}_ zt=h1OJn{9{Cdd@n7I6BUrufqc-wp6hIRN?ku2F985#y7#3$?Kuerm$pP@)R)G$nhX z;@u3ti1D`z7?08$4K2P77K7r zapUDb;mXY~Gc6UV)~psSU9;l;tzUo#+b!w3o=m`X)zjpPs*Ru|AD+RRR|Kh2m_|~R zIcYYi5Vv z+LIbVSs1?e2f14Nfa+C~ojp5o(&ifzEcsOgwGQsv%#$x5kjKW7tA1op$q>hwR z&1g#!d`nkHnmRC^BnT;JD;P~Q$yBjewA|P?G|q9du!ILny)g$Ws&wnYuy2Die}K;@U9SFI+$Z zdshmw9IO?b9y?;_AqcuQAkDc}A_VrfiXr(Y1jzaHvl=fGiisu{icFQdn$LG2IxraZJPuef!C3NZ&`$rz{2jv=7sy6Hya>I@iHz&?D zI`uM!;kN}CJ1fv3Wwu(8j}5DpCSpJ}SO>eiC8}yD6T$WhzPp2r<^L%LebTB*x`9iz4QnNlSxLi z>Sz%3P9cS$ZzEYM$h2W+k~6PsP~e@V%o4nioXu7Q4?2-#NhFbacwbgMDj9aFAwad6DK-BebMF~sS$d!M{oZuKjh!d%%q%tl#4aKM2p~a#U@`=n zxyq(3mW>jtYBbicY5ya@ILqX|DRAyTcA}+va;IY@D=9&Zaix0}Z^igRt6iNgYx#3YRC zig^LkS;M7^4WUXn_m+2Z>fvuANfW&DL=V%#;e3tVyTWW|#H6m+I2IXh9;c}aY&oSK zj~NsNebJ>>n+TcU(>1O%k~0Ix?(Q~!{HIT~Wxp~|ECi!*8zGjbZ9Zs{2&|2yYZ8$M zyo0s1KCTSRMsw;kphQZqlj75g{q43PUW$N_38_(Bzc$C1i1U_59~|=Bi+{}5Uww}E zz3T&f$I18b+$*2rmCMf~RDd85TF~tqLL=}^WNV{Gab<#_K}12CN*2{NMk%iET;|-_ zv-mI}&kape@aRL2vD(jg>g7LX*y|ueO0k&XZJW3=*{R5Sij9q&$;eVHAnOORPGEIQ z&=d{xTC%b(DX)04E<~@`-Mh@mt;e~3<06kd@}2DNeGOxGIKMsP>Rv;dC0G}jPimCx zFt0r(Gfc(}E|eG(+lr;Gq@GIhz9G*Yb>pe62N4h&>c&%44U4JAXiaZL6TBdLAWF27 zG?gdV7GU$9Zp(+ILPoH)q^do68nCV%=l1(;4r^6erXvT9CI(5Fw0q3`aX}!mI!KvU zb7s4a?y6>ELxKx5HsTJ7CWw(Vi71iat;EHMl!mfs6{Tfi=?&Tg!8d`m(*|!P)4evV zz+{5qhQ!GX=_R9a!?ml9-at_mo@N&4u6QO@O;c(%j%oTm$&FnoONUB5YeTSwCEUei zrhoNwu(bl;at0nd1IJdNJ_Ja4`&jibt1?Ytuy&l@$|?HC9;dr{4xv(#&K7C!1S;tP zZ4!Zy23s$PAu=DI=hWj*aN#Sz!}%{>WqJ{&ue6}5_3bGv>MrBdqd@?7s#3aHh4IF* zFusA0#Um#1ugjy=<=ab)Qrsm3LM;8C z2~hqU2F9xL)S*PB?J6Qk6UtdZA`_l=N_V$O|A*8rqITffnGwgx@c(*a>;&MebhpV!0? znfa8b_A(?V$hxZ((|vqsTkrc_fu}724t2XD=^fW(E0XKiO0u4&HvmIKD??Q}x&zO` z7D(Yp(txX5lfM!PWl>Yl9io$x_a#rg@Oh$-oId^*u54dIiUbiPk3amKoWJ^c%EHrB zlG=K*fj~-yj}A%T!E+hfD3Af$w6C<3%J|xgpW^t5H!(;zna@ftZ$C|0)V%4`hsg5| zi(C|v=WHY8PD6FhWR63WstpLvAPq#5KrfmD%ZUeh#@ z!9aj(Ee`3LKzK<&Gn;wlGgv>FQdKR(ZAapcB#E5ZR1o0$PGmA^YpK$%YI_>XU8b*8LS&bSAkWGMvmTUMyMR2?PnwJ zw6>+)y;f8drKc$cd72}oLz=rp!W9jiztO%u^(s7a8Xh?bC)Zj)d@b+OL!QH#H@}~= zZ~b0YwjL!P94GCp(^)x-GCibD2q6-JgV36eZz z;v6N~Lf}lvB`KlD2O8__j>{Oor;eSfmqN+-t8aM zRK4DHCBl;t-g3lqD3|<(w}If1?{z#9v>uQAe1tpvJl##0C6@NS-wc;Aig~H%4BJ>T zkD&B{vR)7mI|CR~`Vwgloo+&} zlTeJujQ0z+`aMpcI*A8@x1`-Zd!w3h6igO1Jp_Y6kGe3(bU^U?5ZbsdtwF{>Q#;bG zVeLeQ?n9PpqKeCumz&v z!87mV{FSfJPq%0$y9_(WsLCrOMxm9UsXQh(j21OY2l9?VnLzFp-brjN=ne!*<&4HV zEYu!*lQHsoM2RksoO^)t=U?XHl_xoI{7syD;9-h#%*&TvKx@f-;_0rm|FK- z-IoHps2FA%=i4@p6I(qNg`_Mio_^s;)>bw+^S}cH5g87SQ`A$Mre->BtrAHpICiYh zd{Gg+#5;wE5oaCVDvqB>xp1LIM2Tt~QfpiT&P9l=uhqLil1L`AK$5D13MxUc0_Osu ziU=)POe!j?**K}&-)jd+1}Y6yML;Kl+$i!CVqdjBOCK>AD48)C7405!-j)Jut;kj- z)_dlKV{c|y?`sGVyMSPzSa|YI+h!0Q1TU$|fFPo^WOBojDo1anJ&>m(&3qoo2W=R8 zQ?&MuMPU&{^0f6>3IthCQA|8d;W>FCr&u)9MXOLwq$Ws7RYZhn^IPwD{=Q%GiOUBk z-n4{EJMi_ZaN#;c2dRP0GmrD_Kln4e_hUcHBk%bOoP6~ASULGF^5Gehe4Q92K3H5+ z;a%0f+VK|e9Kkz6@Wfz=!4ZN*s+7+9qs(_Nuy^%qWE+reLhoG5R_8kh#%$S+)54Ne zKOBfO!oh)g`1gUO+ws8UX1WeXrJphdVS&(pZGHa<7fW(f26De>uUoXj(}w?>vD2! zh>DTXtY$uoWVs^r;ndyYjqWgV|@J**I#^^`L&D8CKEcjq?1ZC z8WjwqMak*o8>l2DNmB%xL>WR8sLPT$ig~esP-AU{7EsMcBw7+86bnaPMnp%DYzW%H zQOj67fh-FQx{7XUD2le)D@i1IBIxBB=U~2Q$kM>Ejg-0))E1(5#1P2)f)HT)`gNo* z40>Bsji=XH=koS*B&np6D_ro{Ixxr+dR;}D2!etj0#Xa20OwqLkQ&W=UNW84R0~1$ z1|J-?ouXC3>gpz0qUmK@Jo?aw`SO>4AE^x1N}`7($>`_nl=G5a_mHtU(#%j*tw3gD zUE!Q%JSp+MZMm4&Q&5IpZ^(R7F`LiG`-ZX%)K%p8@eFMs#)xYIN=KxMbn}eWpeS>UO22WF+rNLTuYHj8TLD zosI?}kkYd#9ObN4z7_@ST=B#Z+nt_oFsUF$htjQ=5E1D24a07i>CCtLW(m;?oQ0-| z6mw6WYXkxr6@#?|5p5d+VI4{dloG@c$-9EIBN0B*?Y2!B!mkH-F0?+h$pU7j;QM~)C;9kK zewbg#2B#E;y{TSZ>m(6_{DOuYh1b^q@Y;Ln9K?ue)o@Y_3OXKY;+Bk zLcR&d-w&&g!;L?M#icgC^=KcUxdKRG~d8(07pavSf;&9GV&I3s%2_h02$a0A*8XSV*AjNx$ z(T-e4u%6IJQfVMWjE?kI1zrk@IVjWG42*^(OZocwC)r$ih>gu-^!n>;?~PgM=a{5H zN(C}9n#~wUgV8V^Ih65a8FX?%VpMAlQx$e%u~wnAY`uUb>|EbQ>s{8?HqlaZ<=SOl zy>tc8t&&n3Lh!5&&vEkDSt|Q`G)+Z+kkDPz2;phU$aE~ZbfIEpGm`fuiX0K^4 zjE)!$DpkzqmaVOfPHtGtB2^{W7#Lg~aJ3-swM{0|%MC&ZjM0RkP+B0Qzz9KEIgC=M zeu`}*p^g{{CX=|*wW{W-^)Z$UOPXbv9A;yWjt#wmp{^=~51e_R$L^?RvhWN$Id$m> z-jn4CP3;J(%}33%l(J|DBC>f((CKP)swt}mZ5${~w`0h%ws~Ya2^9MgTRB$O64IWe zszE446rQSS_okh$VAxN{v%Bo|y8_MvKc!%-;CC$i$#BTu{`-HI@BipW(Yno;ixIqQ zjsW1TAQ)qOO&Wjnv}r%yex8?Jeul2N&GQ;<4;?>`SP_>*uIO z;FBKSBir$7H~_`Ktp&>A4vN%p2Z7SjQS5RekT@dDx)b;X-gvUozpl$VPZW-_nIoeh zREqv;PHATpZcZoHtgq)(RUkDDdLXcsB~3hUduxZ?tC#r7)4$CFr#^s|0ihj>svv4Z zI;lC{6V#1|vf=FUE%xUXzAk90hQ*{r8BOCXXgHBdy18fg$fHB$m<5CSJ7^I6T-;9J<!~p0)eEH8p<*fgkfcv zK<+4=rD`Il&ScCNVC#T)k-V#E>b59&e|()tB8RkdEj`Mg9O2tRz3^izekp0z>BWLBb8U~M(0teUpAN(YLf#wf=F4`}xGTXB>} z5PK3KBT^fZRMP~H)G(j6%+J<>^%aSX364nCp&i9~$NEN2r!S}*K~+T}mi6@>*RI#h z$DXtSlSX!$g015{(nMoJ!)RVnHPFip>#He~nWPFW!&Dkw0JUaEr zRO5rEnmU9?$x?w3?btX?+k~5@j*RweL>dt?FrNujBHD>vfZ!sjRM^_zMew#1m$eq* zCk*_Zzx_8k`9nY4jzYt&^}fsfe>a)n&4rZ^x1Xwq_mfgGo=lmJN4))Qk29MJqU^S> z;O}q(bxy*GkHY8$SeyqRRD19r2D^sH`nhww?V}&#xqtEha^txdS_??LJskVc41b$K zRot053fa!9ArgH1HSlFg^U{m2E5!M;gpS{JCwcHVFM0SB@L}D8r4k2XoI_zwycyMY z3tLY$zGY`kk%UzMn zd&anA_7CFL3a=24cv{7sg+(ELQxt0eu-;ptF$KA*SRH0Kt4Ja^?@3d~>6IbVqT=}R zb!;<5sy>YkZ10Q+Qj(uE{NYnyV)f-4tcrC)lteuH6U(r(g2J#jnGyCY@?MAa)jr-E zM!OR(Uf$*SiFJ(hNa4vkp8ZQNAqGP_TgOnw(CbO+qN4wRVeOcrmq>Q4XV_K55U6ZT zFHyYv-5+Ls?VY^z>N+pH^e@3V>dInzIg3(IR<>0DJAt)<^_2`C8Wy!=EtAwmU_1&W zd0V8O7zvrchXSP(r%rdda-n8A4(wcY-)9DF> z^epy0-9bBEEM}fq3-a6`LZmJo)xv`m6w)JAWM!a1I)wDZ7~7PzRZW^n<_nKR;GIRu zfRq75U~QO@^jsU;SJbR;8G=n1PXhsk$t0EaEGmo61u7FProNp%2thpybT%_Oy+~b_ zq-onsGMhMj9nm^aH_%iLog_%DKs5AMQmVOUv|W?tk*bQg3aZl4??;k>V1KV7hPxR2 z#ZtnEw~&A6+sMEDLkOh^wrN@5a>UI6INm(`+M^_ffROSg5XNv&ZYmB&s1hM1FTeC6 zZ+`Q`NFnGAR*}gnRntb$g`zMg=KI2SZN2>)jlC{OzQJA+}ub^soI> z#^*1ya_%%g{7b*g=+#&F^iTgaVmW=ou8;Ue!0;|$`>JpEjvq0wxfGSBm!9WqS*A*5Mv@nK3S< z<3w=>2DzkS4fhb#h&wRGZptX$2XvMr8pLprdlqR8lM|s$ojn8#3_i2v2T86boDv*;vWQ za>?GTKoO}+k99Sxo9*FU)sd?9G}f`Pk>i46XRjoR1dn1oi%ez}gTACQ5D4vYwWo;^ zV<72ATy%^_4Us^%pE2xqnNLc}(&0*2-!wS8$EQB?D-?A>SvTzNe3ju!!eftqfU~C_ zW?o-pSZk^U)U{)EHDkP2A(O!I2Nl;Z)+~e|Ni>(Pyoga9q>N-8L0vhfvw)P6?duLL zBZBq?yN@s!CWJ=P%pKS50_!6y{q{H63rU_^ZtOZ57g=31Xr-|=%ommrKqA<^;mLAA zunKD}wsu4XO128u=p#yblnTrj4c%VCpqoNikR_T2wiJ8wihADAGy#NXZ_kmZNo(OF z(##?Flvy1p#|>FV+ZpKv(T6sVxA8<3k%=ZYP=$&lHCPM9euecG7Zi&{#9D`~B1$Qw zR`@E?IE8h-EkPCuc!@RF|YiFJj)d=WpLAo~MQs=cc}ps4E`sKF4e4VN!pqTlJTwz`J% zmfmm^l2wXkiFF)|R1aUVHx?dy_ec5nf9h8$i!nE@zQ}0%2EX}t|0b8e@+^}pSJ{2_ z6^gxGL;}r0vW^ze>F4w|HV`o~yLJtuH4nV!J)HY&-$>u%oj#8e zu!!(k3*WBWC^i*uj#ibpRlRx$kZy@V>Lq{Ro!GNDGVWde-rR35WxR97!ac7sZR^N; zWh;77M*(vAHn%EGBe#yxm+PutQz^&$dlBQmiGZ<_)I`1E#a_>Xh(!Y9cRi;EuT9D8$%w<%ffkQR3LOOkGn z>8u6y;~}ft^V~h>@}h)J4Enft3wFdsK{U3>`z zroj{$B3iPprkGfCPoacoI$q#{AkQUIx5o9sY9x|S7M|cGd*g;;UbH+wD%Q6Yll_vX zpL(8?TaWO{h39$GnK!ZV@PoYg%F`rfO1hb|KdK2ra`H@0x$p=tnC(ZZa>nY0q-g>= z(fB4(+cr`y&)eKgtu&1foPE;(BPElurDznH5)_L9RAg2Pyo>Dbdlu7%{(4G(JtIvb z)s9CC(5Yf?63F|SUJBDuLw{A0^%9yY;)5W|pth2%qwzkVwZ=A@s&12$%BJ0U4+ese zD>NDVvw~_7h(h8*Lcg0*?v~6a4S7crT|{J#&9#K0@l5BAPFE3PWWHCCeAC+ zQ5X$-BT2b{WM+`cLsYD-udx;``T5@^ z%;$(s$f*7h001BWNkls>_=%(Y+t*=+aCKCLI_A9TQF8R zwObmcikocX5Ny0_6|TSi%Rk5Ge(Qguw&12vZ-XC!tPh@ugLnV=@1>fI2#w`KAOA@n zc;~wyc>eGg{{h33Cwbq0@Nt@=V0hvrtEV5p{M3KSXMf@Ev2pe|-}7JpEt0{2fBfS= z#-%5|Km_^8;LbQ2HXiSS40p|Cy~FNt8EmA0 zQEYn<->=#LZ^5l?96H_vLw#iDxa@@#N03Y0Wfyv*lrn;z)lV#H`eQ}2={5$7Y* zd5!Z>77dM)SPymKIMK}+B!aDO%DiaMsitZybuGzEjtLI$TVu<~)h?HICb*3utE(NF z#R8c~-hApbuU_9~QCDar)4F6d+vUW$lQ<8K6p>{#&hpZ8zX{EPk=Gb&k)lJd|0u^c z-^UYw^m|NZFLUxlLO;*gx$p!hj(?CRpZ@1;3S2B${FdKDOR8?*rW)R8>NfXDnoe6A+^(co?pC2+oqGf&Fbq z-b+|L)}yvlDjP{xGS-jxC}xhTsA!mBR1YaVm8}U{Vp2iRXo^WBNd&@pIz5eYftOx= zmg!!_@prrp7e?f%V$lBn>i-0n+jd4?&EC;O&i*ZBLZDH_m!(f|0l6r`q&6N%v zqe%x2FC6o6+r?AZ{K!4inJ^ifKdMi*$O1JOL*o zgHBFm1J1YYPs0sO3;{(uK2&R(B$JdygA$S~Q|<3cVM(&PM8b*XvDeB9tZ%Zpy2A5c zdy*?xRycR=9JZ-m+Y=r##pb!EnEzk@gzCvJgEojHg{s0{nG+C*?VQd-4-wR015(2B6XF=tZb%|J-=N&#S=MN8Mfon>VTp&%vcOcn>dJOdqX!c<- zf&cLD|3fA>wsBR>_{Mc!`RbQ>*T4OP{Cof4m-zY@{(yh>Gk=2%Pkez>kH3xo_;)_d zL*Mg#eDW9m9;(;p+Vjuy?0@$gJoV|%wPg3y2By;?I8Rg>%S~0|p)KJM82!Ci-g0E# z{f<)a@o$#f?so%x0XP@oad{K`mV*HF5`$ECV2xtQ&v%>g{b2tq#Qp6Rd4u=4o3HWN z2=5RF3e}~Z;w_=#%eR+zkxTo;Lu0?-_C2<^$4E8AZ|t%E>$v8#29rpL3zEbzFRQli zu8E{c#>#4!?a_?Uq@vqNSy|Tv6uEJ%<~f>#;61z3icViryFjr&C10d0<`qpD@e+nQ zuygeai*80<Uoi)tu~g85b}u3%0LcA?a#5-9Ej|6P(&wNAHb!=7oPrG5I>FhW+V+ zPNLWxcF3fmT8x+#mq>M&wLGPpW%RR(<6Cdy_a_ZkcSdY&C9JO)*4H!k#+IFFplKv1 zN0Ldpd5?ZavbQ^CzF#vKrVIxufq?UtP6v_!I3MvM0V4CVqSNcr>%#u^8n4@A7!@On zam0s+5K!94tc)NO)-^P>CkjY=0)eL}B2^LSuPCgrdsk zRn6}9HedeQMHG@}p8YBtn;R4h%hiitMaES={2f2UXaDF|XZ7{hb z6&mkbEy!Zl;Om;ao6s8=nkrB)9LPXZ3HmDYKKnH5>l<`B8Q!^8RVpO)m%qsLSAGdU-Y0+TF;vz;SVxEfA0y5= zn(37BQ%{kuZ?OHTPm+J|J6IVG@V;H#%GhQM4%SW)Wrxz1H(N56SfjIG-JxY7;+ja~ z+L5WXpgXYg*b4LA1=Hs(GSxiz?r-H+e)hlQ_x|DkOlWFGH?H&V{#XAEPyG6?@ulDT zBwE4fvwuiEpCL?w1#Vn8&p-c}zs_*$7$5no{|OI$@I!P~*BP8Vh4&5{T9$a|b+ZRM zF_t`hG2Ua8`i(Xr-zj2l>2n!iC$vd969peo2P4R3rnt1HTef)UB_-!AX7@XYaKt@? zMe#0g-zYdb;H3y>B6JQw@i4R?aQ^_QmQ<`l+&<$an!?9OK<@{UD3!i*%BPMKz@+=Zs0%*wAe6du&i7CP#=s<7Rm8SzFJ@ zR|VcjR{M(FM4Z!%_APD?glK=#Y~A4NNS;Zgj%_)!)>vra?2acWL#O4D$`TP?IQ?a$a!T$CXZKf1; z&3NHRGf8leW+}l%YUlAWU`tJBph$9!YaHQ#H4_#4;|9Cpi8f%QqLUdGjl=nf42sci z0lGc2Yy-PZ!TzWrO$^;Ur_)s|e97pB<-}%6)-^PhMGljBM^gvt+Tl8&O{CM)Gc7;v`jZA?1?lW58!qNGF$s7eV@A5qL40mj2o zpjlt1x3Ph@700%=m`!Iq`^?w);DaT(XfTHr8~n zv8wpSmA3bLy&U0@2oH;!k25TlGv5gy5AXBZST)`Z9={h;6nCMz-z=ll*}@}KV1FK& zlnrZZIhA)TVqoD5=7nQ(ZNS+FyA1Q3$$U(1z?hsoN!S=l@(zrrH9HfF41qyU;k9DE zKjZS)!FfkFP0^VlQxZwUc^K6dJClN~l>zvg)nUR)M`O|q+swFn=?Sh~`x-t-$|{iP zly0ginhF;pRbzSe%2S*<`3@dA`yTd2Pczg5j-B}qo`2;T^4=6mKaF$oxLPy!}nOBialP8w84 zP|O1=7n_Qxp|zgJ@3&l2RV~zz*tApX+4B_N78stFwpH~#Hhi0@?24QhmQe8Y(KXLYdvWRwr;}- zhHG8sQ^%rc&?=yW#QH#4Nt9LS)FXt$7(>(0j+~7|(uM<+GZ0Er&Ktx*U*urW#^Bv` zlzIq`^m-&&hefqOD#e56&T-+=MV^1|Sss1#&CIV|V*1biDWNRLPM>D`si*nWvtLJj z>-#zTy+4F=j%S|y3eSDz%e-rIjU-91&Jo8m>YeLk{q8|LTtpoF8PLosK~c2E-9vCZ zJgls3fw3+Z{P4&BCR!(GlQJD`bLo|*Isf99dEuEqVmjVMD3C&OefvC%hXQH`!v2Bu z-+P+ag5a|HH2?+h)<5?FKKApU;1B-yf5h+q;{QZ7ozfHy!!u{wG427VEHg&C1dNuO zW5_o$PQ2et);o<>m-l{$&GRpYmSKNbw<$8OiEzXb7I}n0ilZPQ?mlX~lK|&vgGl7{ zYr9_WdOpI&0c-S2AqIgv1EfFN;mFOB>-&iYTz>BHn*|ktnV++o8FUg5!mvBC6yA}i z8BOIFO$)pa_+f)oHKX|mqcscXP^!yHC#RlF5Gs-h!K9RAspQ15l$VP+F?vRe1@p$X z%?1k6)ZkoTZ&ol{RHQ19r-99tobJXM_8ffmsox+GH5(gUiYgFBHRGAZb`?q}rgMi9 z1tCtUnu>Vty=)%;Fijn~zPr!!uY8X8zvoBz(o?^TmzGzr&#B6Yvw{Aa0U?-8EIXr$ zo>3U3==2l19f?trfMk6&WvkmZQat(WjJ;h?-gWdcL!RgC#R}h8a;=f6q%Iv&1$=C1 zN{bMJMd|4EGNgj>WJ=zRWVs+!DUUv|hO<+ietAOEcp58_USn1v={a_HEGjC33>-g| z(8(qFD(qZuxB9(~MhS&XHQhX6Jl?0;*`t|8dcBmL(Npa2HQcyD zgMJ$TGn$ml3PG@ueqWPintsnPx0b4I2u@O$Z9#R~IEuAn_@B14+%jrko zav;w&_>X>+=YRLpy!`9`ga<<)AZhA?>rea<{d4DDJ8@!cd8!YBY0=W|#I)5{TJhSx z@sKepo$%!^{0^V_oqxp3&wUYRtAi}o_OUu2mTVpYQgElB>_gpYPiMPi8(5A2D}dp- z2kEY@@yzEx$BiqyNC};OhwuAqe;wB}I3ciMX~!53MyUcq6uA4a0K9H1$NhL9#hn3n z`OjAZY&YlNc7P+EUrybdfH%b+(zg#e+;#hpD?x*5?4 zCUeJlHs#b-%CxBQjpz7ALboTVT|*-)l5U_36{0Vh--tAL_HK+Bu4J4%)`Jk}Xw9+p z1SLExXCFtdY%qW6x0x(T*86=rnFMJm<^tDvgh(mNztt)-Y-j82*ERd_sWYbnLt5dw5`MTmmNTC5d}$DZLp zk!2cf4D(6*!X@iPbQCxjshakb@;(xsMck!aP9N@Vl75G^haVyk2q6$+AjXI>hGSdn zT>aEUv)5E*{N#Tqmu0|v9_R1$`^kBH~7*Q ze)l#;^IAGhxLrjV6Yzuf5U)gQG>=P}r2YUb=S4}{>+$}-@Dl_fIrh+-_}EYV7wliT z!m)=R;d}qePw~J0<-gQ=eVn5?P^Ru(yvY8}4XkMEx9+NR6t4r0hmZdrDLC=&MDn() z06yp7+jJY~eaN=-lDXd;2>`eS6ym*s@in#W>x_#3EMU0+&WDyU>Z6^M%kLku#{+?m zJ{YAQwv8MWblulj^_$4xKbo}W=`731yoG4lSWSpt^2$|<@`{y#CQkyhDljc8$}%wB zj|_%jeT@*FvT+BmIvbR1=w$;2r+Z8n4SQot_bkZ0HH@gy!XiY?)>=yK1R0M?!=|=Q!m+LRoJkWT3GHgVlF% zdHZQnt;n?`B$Bm$&bU~xKlS8Uj&+W_Yw%toMWiTeToa%ZiO~}y?9OZAq-JHS$8dGP z-d@4}xS;XS>1q<;=?@GIfsiVKY}r@VRVXdVQcaR7c6L39G;LEw0_8k#)z2|$LXt#= zLqnn=GabspGoMVZiZIiqj zwDD%2{^BnqeU}(uFznGEWPIzp-p^x?zK6@#pW*tAJ+556K;97~Qc{&Qbq&k}DG}=x z_1q(3LzZ>e+iTkAt0YwuNxPA?m5eAo<-Eqxicsp>(&-o${~vpA8e`dcpZWdX<*awF zs;=slyGV-KEnBv1YwQ`XiI+^qR+t$t2@)q0BtQZTCX*NjVr1YXaAsn|AL1a3CsqtQ z&Ulcq;<4jVEXgCuGDVrPtc4WCrOEDQSJ!&iv%XtCoZDov+1+f(B0yl~0);Mi)g{io zRsBBa|NNh&GI-_52A%CLOElI7Drd05)5{e}B54d{nWio+btP#_*u7HXoF$7Bbk?1R zb={ICFzoesY2Hv)ig;?7Y$=i`A$ZThbk#-iMUur#VjDx-II=uqFiNS*z-rmj?@O}2 zplKX=qS1+9HtkBeVq%z`_iuLg7Mu^JX0!Y?zbgOMR-h^S%DLjObIOjWyz~`RePyXru&A0tq zf0Oq=`nPDSir@OV|ANnc_@DAq|KOK-?(xqso6q^>zxhEHhx>RN&@udn_dh@^)_s(B zX!d{Ej&Y0b#@CBpJNf$j>j2AR4&I|+6kbcIniHV_D%>F$^4c2`!s~;xD15eWM;%_Zx%+WJa23?jFaOMlowjE^H1_ zLelREigwA}+uKMNvlIvPb{s)exJEJP_eryuRZ(KCKuXQ=vSxb}lMBJTFlapSWR5j` zuuHs8@p+%Ed)`jI@c>Uf`9~ZazJO4UMF9kj5U^M_=$_?U-tmK+-~3ko;A8(2WxYa4 zft0YS8j8{(w4*+T-avA=U-Mnx_BI~>;{Sn)Qu>2?Fuvwsb`7lqqkhb48K|8_X^F2S z=|JGUpjb#Y$2m=F@F7Ntz}0IDmWw6l&c>WQlhYptriX?}E-4B}(^&Fhim;kh(Xw3D zM6qXkE5#baBu^Qq5zAGB6)|ONXpJQ%5Gz>Dz{H(rP7f2}NN})Mb=xpMJVYS*qfdPZEo*v%hQp(4 zeCbP{WIV}v_uJpi#Y@jpw@3Ww_xv=!`+NTgm1Dki8yE&djn)P&YbL`nsZ+GJ#wx{f7N|>b&eGQz$JZKkYS`S0 zh!Yr2G(s4p6zrTyFxJzyEjkG_RTm^P97?n@4EnOOibzSM1R`|ykvJAO+ljIIrz3(l zn?lGVWh$$bxS{=MJK>JNUG&s>}Fww&i)`CKSp}Sb(sGCfD zxHC``UngMPN}MBJ=l`<|@D~;yP_Q97fsp3av2iEO{h&quiaQ5;ZsJ3Iv!vflHhRpK4Z~4a`fFQD(>VHrgbR~RE?&LL z?z|yZlEzeQcG6HFvcOZfY7k44d=Gc&<_`A zqCWkt4buJ&&wurkT)pxvfiCJR$^d8aUJ^p!E$6?J3p?-N&!76gI5^%X(w<1BG)m9Egw1h;AfRMmUIwmRGYrQtJ1z*K+jGWgz|z?}vVP2R?(o5&C3qKz zdl|*CLm(OLXY-TCb!y~K<93LE!zVBiBO7QtV{siCopZp!%Gf(m4Klv>N|Hh*X zA9)9tuN@EzFm+4id}p&rlP>VqyY;jbumR3{&ris}V*{lSn^r%tnd`YhY0&vX95{e1X$evQkQKF8kPRbIOMB4yhFqYv=>Gf(oXzw~oF z_th_>*2^l>hY$YPkI{FqnLz5ml?}5mK80ev>lED{QLbg1*VS?^yiUgG9RSShDOdRh z?(OEl6Am7ba9-Yg$Ea_#ZQN=?yxI5M*c1|8EfD(4UjH)z&WVmvy&ie@nnsZmF>u$x zQryAK%I$#i&60jI%yRatuCgdkG)ibDg9IH3t{&}C)HQJ$abdiP6qcnasM?y@(x4(i zub(2?oTl`oaY{@|XdObg)ZSyQz=s&?1EaoXZ@$m@Gp9&YM2I8yUiveN*^`}+B$gQC zh?9uAu~bdNyWaX8Jb2#+c;V6~XjW6+_LdPx*BX?R3V+s};s5=F5iKdW`cVkwV3awy`XimZSL*4BtiSmwKPtnUF4)flw{ITys1PG!={{ z5~UrLF$k?l`cTykk<=Vt?rNdDw@6``*CiXLJZJBbxHhJkI*b+gASsrfz1=Q(Im;s^ zTM2_9)MW({>e^zBr9X;LD#BC-i{yCEG8hY1Ub2`OOwV!eJwxU*e;X?G`Vvg4ZemKap))OABPp5Ui5Di7x$d4#8a^7nrYFf`WhW3xAJ;y{puwE8G;oV~>57Pkr*U#L0zVWblb?lwG2|&6N;CZXvqPWe^=HxW&-XvV=@uH<@9L_+Y z491I&ZX{w+)F=&iZH>8SxW)eTm`exqj@FYA5{MJn*%~pg3YLYTs4RJ`sY^j^9Cd4% z7m}@Ej8>jx0$(})GItFhU_Si{UX}E+2p1&8fniUhP!uxak^A4p*`0Us%yXY+YwHZ} z`Kv$3eD(|n=cW{8!E$+#mv%290^ECH#0ytG#^#xK^X$bZxpMUxVg+%QFqoX??GODR zFI;|#=PrMdD3vIwNqU;f6vQ&YJBPL16!4O0!9kK}h&*{OLJG-rX^10@j2ua7kg?#Q z`v+WnzQH)hWSpXW7n4>QN1O+;yldW=aRZz)|tnh92OhmIt{3xtNYb*v6clom|J33(o9%bK?8lAL7}Xd6%3 z6Wnv(kaA&g&XH!4IMxU+*}Za&+Fij|i80+T>X)BiNbr!d}`5=B1tu-66BkT)&z|8-NdP&mk3lO$Oq6HCRB4nv1nL&!DuAu zOU+`{f)wZ^VLtCXjje4u#jgzrOAE>~FBc?Qa_Ur$X}aKn?bDh#fxTUa z4<3PFwdfe2rYRX@Dd*2k2*Pmbr4`miG%F|;4%>KqXid51x&Uw zlCzf8szyjpJ`zN+qHJ4aByLTmcDN`&>$S?Wnad>xaceUnU#l?f!7W@Bqe)3hu~Lsb^^k^<{3Sx;e{=hE>$*QP7-I7bM} zs$3CN!n|ynU0V>PpUmqib$2BwVv73($;~vFE9?Ag(Phl zYzY?2K%RoE490YVi!6mK@@x(g)O~`*ks^~4mA3fGQw!0h+#vAIlE#K}ccmQ83a(zQ z81@t!W6gBdc}EACWIk)DYR8~28TK_z(XebZfwPhz1h&x~2&9%`Y9T<@i;3chIPMxLya~jKqOQB0TNHP@!{cjRfyC&P z!UEpM2s+>3!BN2b?(Vv*0^W2ea(qxDRiHmkz(|&*A=a9mofK;vzO}SVP-(TWtzqDXT|xiqX69<3qdlGReM zS}3+pcU5Y|B9QkD`ABng6cL1HxS+e?KJH=v;Gi=%t`Eg5 z?nFC6zPe~w*qbX?#cg!>4NwS}I_L@56y2Y%YUtqAhIsKcn&WRfVT#*}aKf$Bt~Y$) zhkodX_|4z^O&)#pQJSWC&2x5rR}6fQgp?B@0OFNA(K`jh8$W-e_Hur`YkcVXZkHRn zCa)`0*UD60Cl^(6^Dv^5ug||pCdSFA$712BN=rY_@Lu4Ih2UtcWf&(+i<+zZC3R!i z+04k(fR~!X(oq%$D*`fAUD2zLsHcYE2+o{NF_q+CT9E6E$sk3lh%=`KG-ZuuO`b^d zT;jaPILWy)XBg%=|KhRVCCW-3yzg7s9%sCG^-CNd?s4W^%Iw+-V>L=kY;CZrtF(&x z3Z*oQqXtvA^m0YHwzT8}O`K@vO^a5F_dI-t#eB|US+c4ctPuzst!X;T!K?t%KrO#O zMxH@Wk?RDl8q!Fz@{+b}AZwcVzJ)APPx;J7zG5K?r8Y6=@pi z4<)UI>0wJ0Ny^GX5y(OFMNS}?|qob_#D^vc3-ZI8tnvHXQ@__@rGt&J0i*gwv=eq8Tbc-h`M&fiK1G0 zie*4Y0ow%PM59NYDcV{n7M3iPXssxgExk;m9gKz%Wot3UB84Q@k`Ns8S;Jr)p>@pC zRFF8XJl~=c!655S)!=w#&E*|3l59?5yzAT%i&aB5l$_es6o<{4!SkePAdV!~gpTH} zC8mhzWif*REN2zoTdGQ6jOf?|1aT&58$n%g3o2FI;PqPj0-bXR0lo2<=O){nzI2J! z+Ai^Bf1j=G)7Z71Q2iX_uL3%Yro?xbi$SE0GWwbhjh!^><~}pjdF|0@m62Ilbz%1?I7E> z<%fUxhxv`)_ziyYCx4Q*ZC~@8YVCJCFCjTGHOd>_o38~F1vmFKexvYZFLX^Jy>P>% zc%rva->h@<>-@ZZlXw}A4`&1y7;eNwk>UQ)1WC)XT5);qkXlk3OKqUCj?x;GNEmFS zl=~ISWkr;B4G~f)(kx;iHC{EK6TGq%bxSTCm#@vyu_r=eM9cBQV~s-REol-F#{*ut ze25Ey`P`G*gvMHoZIMb-lqJu-ctD2eapxE?(f9-~R1<=JS8Z;n9kwam0xvP9(;3s?Nc%6WSH? zKwEg~r634Tln7Qwo@i$1#WACSCb6FR^oYDK2~v_43NIvea0H=fO3!eV;4!3;B1r{R z6=;oLmsU#_tCsmPaB6Ezq!mSdL@Fe4B1lFOB?Ha~>bWP)BjVIjR)M;*Bw0#u9ktpT zPr0h`4Qy=pP|Bi|A%vQ`ad;19v99Zjpf?m<5=>v>RsrL{ujxsLKx;)C9E)Pkb1yzg zq!e)sB1l$;0jUF7FQP3JtC=HC8xjjxkBdB6mJv(MOf*D7vaCGSDv%Ea%emu$`!lMl z;nMRpN(q$inne7XGTqn^2%}iKfSG%23oiI|BA18S(;gUl{Rrzk)r?1DI9{I=1dvLIfqyN4m0ig6$6Qxa8o;}WdHXeo zptyO((sl90Vhxae0Ta=c?w+Jp#m$P3!`G&OycG=_UT4pEtFPB}O`hj`@Pi-37{kx} z%+F9&)lDbl%N}+lBqwT}uHPWsDJb3!9KX?14|3EtU$+P6&xHGwA9R|kfagbN32>9rX`LNv}zGrki`j2 z>8On%k+9gaShwPy3q8)B>l3@cAjvVd<#4$I*X4tHzPr4p65Y@LNvYNk_*7oMu}1O#PcF%1+=Kt&oE6is6& zjVDbah7*NrC3OXOO~0RWJS#9&SFP2CfOVE6fx7Z64lLShnjVaMlJQvMg+nOCbOvqk zjC(OY0@Jiaxn!~#Aw(B?QI~?_1IuD5P!Wu`x-j}Y4;=4Gnlg~}75Om2*0&JfsF!c= zJ;B+RlU@8evJD~FIe(u0v**!=M>HPHV#$~O(f>?->J&fvlRu6Ang4*`9E&S2@R|SN zzvWZE`P*EYFW3}w8@pbKl;!)gtX!>~5Ta{@?C*ca~j5WW*}h`7mX5VxNs zi=yC}XP)8rfB*OS`Jey!+rGAzuJm{;APYAM6~FPC#Os5KIMLhqjZVXv2bhU&*C@q_ zS}oC~5sC2n@A;ihj^<4=G2VS)%&KjWlUD7Tkb3Drp!F=k$)`$t%#?b2vw)$gcwa2=e=|La} z$D*1NX^(d`&RV<+7fCjRRD*9K zvoL3NzIp zwIEMp4(Bz}$5<0{R9U135jo5X29u1S1WnmctUP(9Nm79enh*pw)bwJ-!g^Gy7)@dh z4pvl4LzG4MAW^}Rr;65EqNJg1G$0sl#&~B~tsFX*qytG^w-oz^JXhrXKvj0J7T!ya zr!CF}Vid+28td^P2O?bSQBkK*Evkmyg9=+f**XLe=YeP-QBG0KEw*t?PHA*5iJGp+ zA<1H#b1VzNa^8~lI(oIL96Ev83XGH3rrViDiDGU+=s?!fTzjb@A8TskQ8FN+z-+H3 z(g{&d(3-&B)fGOtmpdZkOd_>pF}3t^$)b?>rAJCg^G-Ar=aRwLv%l*J4V*d$t?iQB zlC*2yh?0aPSIFGmW?~E=LI7(!@y%M58bX(WmiPLMzVo{{`18-9gk;(p+*41p{JZ}t zn{Rs?*<_Pux!{G*eU3|)t}-)@tvE&w`aJLh-_LmK)XS&k_V#J6UcJI71WZ+S6XOX* zBqy2>{0-{D8>RFvbTsGR*6`KPsac=(uzG`bT`vP9(4(^tT=xZv+w2r?DzrJ_u?x3Q zg5Ip-@n%ssH-gWHKJ+1e@fUxQ-~R32W_x>^{r&yhzAgtG1?U5*xcLrM+yMNyofy|Q zDgF&W6-U=3a`uFY|9Y*K6tDdqdd>CS$@Ra<#5bpQVn%Jk(R7ARA`a$)wvm8i`*a_< zEEuZ{Yb}c|BodsYmny2dWHQJRji7WT=s@F2womsM=Y6hRJ>c^0l1Z!>jAKmjgeIY% zXG{h$QB-qSIL70^(UD=0OU7A3@Bv#pN+rm%nBfSVTk!mIe@t5j(q6`}cZ!QId=?=B zXLe3;uwP@^C0VRU;uz}%weeK8Md^eWFMp1Az5RO_$1!mXqtP~h_T}GZb2DRm>j4gq zFVePxrVX@JKn2J$5SgZ~6j5qPRYXw-`kBOf$hqDH6BpQuX2}>QQt!KWp zSRZI*U^NxQQO3$Ss#Qy49IKT>NEi(@8@&;3+F(PB)DhCR^am10MK6me=bmEKlIC6P zSXm@UB+eRqfUO;k5|XxZL}^Su5KNp#1kX5CSO;3iv~`P8g45@7taa?Z=vW+CBHabN z`ygmakJb^xaiBL4UHgR&Z0*EY2lHuX@UL5_mI5g)ZC%i`9@BdAUPl9)ro~!;Yb9CQ zO(ns3D7xLUlY;&rrKudNd4qG3ssy1dS*9tQ7Og#59@CTo83~%k(i>>9VT5ZfN5?JW zjUL{^(NRlN8M0o)YStozCy5o~?E(ID!fI*BazRtnq)}kB(PO!ERLhz)=`r4vl=GJP zv8N3kyIEI~qhn8!DTc#{Q=2Kn9Iot^EM|_P>H^rKND-W4c3cq`p3z2hYgKAju@kz~ z8@jy0>%i!oC-3z+^T;DydGM{oPd$m2lHIc6;8M*Cmv-^qQ#r@Vd6ZI|OA|sAG5Y@R zgBZ;)WUWczH7w6|by)>5^a zeovE2j}nk)Dch5CeD;a|m%sA9N4aqBt?ci8ftRj4$9v!V<9y;zKg7k|D~yJk#AVc# zCpgESKK=*1|9#)j!wlJkZLUjyGIpL3ASS0320(ZGY$B*!5D=g;rQ4iq-HVi zdI$v&M=e)&XS7wItt|*i8Y!d`SR3P%#ry7dDo!J0ZD`wussd{QK?<5yk!Bi|NRqxG zN;Q*Ff^95O>d_*>G=Vr3oIM*+nHH@DXYY|5?-_y@M!TQ`-?uC7CVkIypw-O(3EZ+Xw-zQ8Y_O+Vgnt@Lpgoj3+&0 zs&U@awuYkv!?8CE#)@HI(Ut;hI>3|&gjWp*V+ z0YRF^RAnGiki?oOfYO2Bn_Enb*AF{qu~oIs?0jWn6he??Ia_DXvi*bqIxij^knHa> zl#02vEPXdsN?;O4Byo)C4d}n`TX@%x{0Nhc$@#yO_@JegQ>-qm~3NGQbfB%i1-W^?Nfn5Kd*w?uxaR;yAW}m-V zl5e~f933vPIxt3#$jAXL$x!<)+8n!Nb*FWWk6;bo{W%KY}=4YNa6_X z1(T7aKiZ(tE3O=_80VUDW!UKlVyQS-Sr$cS6X=f}!9|o!%RyC<<}s)Hee$uUZynY+ zQUMP?_*ba>$JjpgAfsWz4}AAeaQVuY`NNO?GR7|Wp6~jPc;YWU#g(hOjQV5hYD!TE zVi6Nb!K!I_;o?_`qCS^)FY)e2zKh0MYO~_K@B9(I^z6r&uckmosv?@&Ii*M|0vVVlgwc#*;aPX$`@7M3Btqt1f&1!Lo((TN5%ha44ZQR8@|=gh z^;;>66}un*IAQl1{jwl+9v?-BUJu3-tSHS38z60e>XMc}p`Q*j4^oRfh5 zW=OwjOwHxpmZ)#ZvWP*yk8KQbKhRohCZ58N z+ar#r$2iw=`SKt0zIXfxSC207@lXF2v)Ls;5@m{aKJ;TWX3GBIV>GqkuYTZBKJqVq z9VHyD6?imipxHgXjD5P|+}0y(kKf53fA$~Y?2?_0w{mXlz3d)+8X;l1T!Pn(vk6ID zyEN#+aqjLuqcZ~68uBb6+Q~7Eqgn~FNRbXSJ~({a zU>i@cov6k%0i`vbuCyKRF>OZ$X1V6f={{049PUf%QXr*6*RZvj6RkW%4V!oMY0DIy z7&fwm#a_k6>4Z9oSrrN`Je6(Gkzs$=QkRarFY(4BN$|lUrAG-z96@gob$;>MA+#U_ zs8(H4O&SYElZ555BS|E#7Bp4M!G6nNBPB^SLVD`L;TunrK$0pTFc@}|Z7md98e~rs ztv^4Wdpv@y*A+Yq0+H@I5}V4CC6Y`ldRazQb{j|n=MQt1?MSq~U`clJU6=_hMv|;#SD->k78C4oy*~iJ(0Y`CScc)IM72hJ^Zs0!AMb14Fx`y~SV*ho$n^D|2Io;uI z>y8B@;+6WRH|yh#yfnL}RFm*(3R{S;eKNe&_k}kJoqBlWXidY!rECroqNp<`8ylz# zgNnem4Kf6li-tUnDJdZewrDl07z`A71dXZaWt|!Q;?H1MP)GFBSgYzoZ`J8Xu)(gXFPGqSpWba07*naR5gQL zRgew@5rNRaaFpX)OA@7oU}!|m>ey13olM(XLD{VLc@s_STda}T+M$93710>S-eHZ@ zp20Xpi3sZiWl^DYfzl48QwD>SQh>36;ie!>V&XJnvzN0d3$n;^`t*?FRY5iFT2;IQ zYa(2m?S1dd~wuAt673k+0)04Eh zA?eu;2P!z+FL7duBu+qHzwDDxxe<9|;xi2fv6W$~f<7klM8ZedR=&B{#=uGI-1IH*+ zM42b*MTFKd97bp@FqI(H3GpD}cv+DoiVfB0;04e05+vIhS<ET1$ow4ytK>_c$P&;Z6!)|5tAF^ZQ^Ky z&ph!F+EDYpZ~iH+9Xv&lE8`Q+uLe!uIJQVJ4{SC9Uv8al~w9NppyM3fp*` z_Y^Bj-pkf|(72C&L zoD33r8#xE73MVYn{gPAn3>AumrVPv%C6%dZYt^+)w3gtv822YkMmwmuht{1U)OkzO%n|G}pB=C&7dRIf z#t}*=no{FqI5mtoIx0EbJz%l_M=Yv+zVkc&2G_1V%V)pvQ7)Xl51NQ)FMpNQ$}t!y zhFOfxbK0h%oR$nGF}9Gr=i%?*{LYZifAORA(wcs%&>^R_u-Q9}mNm;p;_4OXl)h5L zQj$c0QWrQ@2-&Gwy>kQ$W#z~-Pgz;=JjOd1_6MZeQLDgcm{7L?tqhU!C@s+u6e~-) zw0Ie4OgEjXBqB>RqO~|LxOP-hRt?@Mf`KR(ET&zC=j4J!#SY&F7Dd5q>PZrbRM57a zdbReJ(PqT8%YyA;kGfc5j3p?6h$Yp2OH&F)TU~g;@zmj6csU!lHEX}Bj+vZNY;8vb z+i>xjmL!WAj2sdR7J_$p6EICff2fEOOYn}~P|>sj9SfR;Ln%RjkdVXz>kU$MX8v9; zMn|5i?m$q-UHqN50&l?^Po77FR?;^WwRS-xekV9ZkBh>jD1s%hOIS= zd5gjF5*6AU)AR$<*JN1_*9LlN%Hg#ItNnrt7q;kSck{0M&vABZhsNsvpS|}CvMfFC z`+jdY>E_NoX=iq3XA`iqi3qzSG6{fU0vKVjY?_wDl5LhlS)gdTOxcoHq(qxV%4JZr zBw8d*QL;#p0tgZ$KtvK)EEc=iJYi>cdO}af8&5vxeP4e#J%iraT~Nu=2hCH})%Vs7 z=iXc0=YOB)`3KTUGv8^x1be<>mekFtvMxBVoKsghaXe&u=Q8Q^D$Y$=o(rgIgUcPl zIfTp@jV3(wz_-)#+dTfc$8%md(>`g^0Fisj@C-S?qr+V zluVNZYeJ5$9w7`RS9e}wIw}!Pqb0Oj5^Z3#Ss>6Tzh>u3!SYgsDRYLqhPgQ(n?WHA zVH+Y5BAjG6F0n!|nD-bD^TtFwY9S+s7uCcggOwhpbWG!t&{ul^VwvWac3)A}AcQ5v z5Z9I>(QNNb2|E&vM{Ntr+~5V8E&;>siiM?sg~gJ(ths!#Bnl-<{ea;p!&NoH!Qx^- z;6t4VhC|gj#Iyy@LM|Ml(-{j$T9ztq%b~BV#_@N?=L3@V&oQJ0^wKLdCkj?~7TBO&2Rh>XIh>)_RGL~uV z==f?cP`E;1De`9B7le|!uwhF5gC}ic z8sNCqx!tP&u%#l!`r0l=NTObIQi%(J?@2ms59KMgH)D(y)S0E#YEiisqiGJJBJ5e> zxa4Y`<7vsxR?2jk<7>y=Cr@(U-FGAX6YQvft=MwDmOMZ8nK;EHuF>NhNIB8NG7qtIKkPo&vE|ZSD9OcyN|z> zB%821`Wm*Lx@`iYk|A;Tjj4$Y3Up+g5w5UHCK7e2i2j+RO1hpLV;)JKph^ zpq6Aa%kh&3@%$E(aZaAin9O3v!x$X_l_Syt_?D6aWorVZXhjiL_@v2F1Y=9e{938pBKp(AQF zc8)@ov^#=i4BB~U9Lm)US{_mb*rH-%J!5X*@xVg^E?+ZDClZWdmK3xGJ{=FTxMY4Q zWL0T~o%9Cd&=`#?rBGToU7^xwtzi!g%RD0;4!QWH$2j+gf55dr{Q^3zSk^GmO>#wa zz5CTL%;PHX{9Yo3y>*Vh zRsSK#H=`Nto=3847;d{}5>sn}c}>uQ(l}b3CW(GLbNB%WS+KAmXmGjrU~iaheOTD z#Www}kEsR1MfCeE7UvFe@bH`2**?d{`cn+T39V&GoJ=T&a@+ZTk^$5k=IWJXcPOotUhI$GTThoSaMq-RM}hZ;+y zCn+&Rp`Nw^WLuykICuWbYA()M8OzoII6rwOhU5!$L!v}n@ z1>5U2btN!miOU<;j$~Sq6)~;8B5XOXUa%M^X=@MXRTPC|v}0IU4)DVU$mR}2Y@3w4 zw2gW|I4WDCd_!G0rZa;lH9MOIFNFSFNS0bgyNxxVGm<W%O4Bq7)=agGVa|HF0Ke611l%OAE4Q zHZ^Fa>CZJ?ZCy6$A!#PCrirOCRsH(p8z-99vA(p)<{$qNy+kkQ)9Y&`WO7k~fb#4lea1P*BE`AwYEb+c->ZzSsWk3`+qfpEW$ z>{a0SS`v zyIqpRmicALV9uk}ib$qDx+@s873*6w{J>+b*T$b_Qnz0zsWun933LElW!tWzs}sb^8+QDrRxj ztf!E)+8&*5fL8{@K}izls6Y`!nyR)$ZJ#2QC}B~4g^~@4MrsH>#mRdEHnu88y9TKg zQ6Q*O$8=aSi!FA~a6tNkqN=E?8tqF2lC7&bwUam+Ns10Mo-fG@L!Jt%(&4oP2#Ju6 zprfz`raKl4I9a0T;OZJDG=Xo3`Xy=VD5{!qY#8qv!qCI1W~Ha4W>#B#jA|2{7W-#2T>|8zkK;Z@+m5WN!jGaT7R- ze@$?7;xz~_dqRC9zTU~+FX3L`ifgg~rw*pK&e^x>-$V6U8m$!3z^C2na$0N?h6QyV z5U7B%j0ru7>{xsxRW7i$Odr9gZk4;j>lZqT4*Xp2a+gQ6eVi5K zMsVc#DY^@XdGW=^*xG)H;bzI|;3}Qoy^Kc}c;>0cSy?^IPP{>$8x~jE)VblF+wS5m zr`|=H$CReTC`qe3hjcZ^4nN4XD=#zf0;+U}BL@#MX?4-svU&Ms;lGn-Wmr-CxKBz1{a z8e2lp)`X!X9~(BV6ewRXH?J@iXeB8!L3;psT(f)LuyokrdsB*BGTOBaP_&j6-35ix zHPf96V}mB*4@I}*QRPtQ1yzw#SB~DCq&;vTN{p@Xlw@hiM;JkpD+*UrYs2E|JVj~g zsDxv;_n79EvzLaHNP0^iah5UKHLM)+sT^d9C1}HJr%B|QPHRl*vA7`i?dA&Vv7oj! zNJduiHZclgn42Dw(aXGrhD%wX;il zZJm0Y5YYIBE_==I7EKDpbq`ecT7Y;H5ZOKLp}h`RH|-8zlVr2+ak!hV|Lb&)uf=c` zuO{mt;IL@etW(hhDR1mq&)uq9_5W9uMM>BT5JECer*wOoPDgV2T+Z&Oz*1sML)VY! zb$ZMV4l!7{n_Mk$CN^ALF9_QPCq4W?(hYnDqQX`Q!j;6Cpv(nF!gY4y2xLG=2cHez zwRjC<6<@w~gstf|K_}#mVuuayPM(wZF?M|-nPY|J>6zp7aKZzg;+qcp*vepqB`r%j zoq67P>RWmG*)C@}CA6qbvVbJ${eq%~-A#~M&>1L{a7d@wyi(%@A+e|_`#H`D76%dfU&+Zae zB@2r=(yIu4N0B+o%re>*M7~Fr1!&=bobJ5DRvMSpRDmLOj@cxo)A4Dy6k}6R7Ls;b z6SgGDtft5eekk!mN6>CaMM75CT2d7b=bGDu6wH!>>9nM(4Z~4Iw;M4W7ns_hwWX?R z+AU3GD=>z5x7iowWldR>lw}kA90VY9hwn?eZAl>=e&qI;!v=w1Fz^`Kf~qhiPBM)h zVW`o8rbsKM@$0ct_W(fdMJg=?ke<81wO{@SWf&pC5aBH8&Zr^in8yArk}xMB^c&;p zkUd+p>$u{+zAJoPK->>_`#n;5Z3A)lIzabt3y%Ab`wGi7@yh)pdm~m)G$YnI0V}RC z;2r_%?$#diR{gs#S3(wBuEi-%mMjh0v18zl#swgy}n7Q}Uh z@;p@3p%Q|5Cae}$sS`yYa*p=b8R&xTT}3?0SdGS9O>2s2%^?Ga`YC#(@gi91Jj;1^ zi1X?c=fweLna8kJI4?)`8hw~5p%9Wwwj#MY;$*kQy-O|Xs-mnbkea2Xqg+^fo;1}w zclHYm7W!xz5|X+z90qN0(b{>}- z&V81vn^#y^_3?a|>`v+T7OBdd?VYVX&7{TH3ZWEbR<)UqfgiDScPXox~V*zuW-D~h~iZn+6rt_$!rBvZ#Yu#|O%6`(vpT{)z5XkTM1 z4_jAcr6XudoRU;^#VpHN?6jy-*xs7a=^3UI$GHm`!WFbylDUDRHj-Vd34O`V)tI0q zi26|EhE_`<1CPnfval#I#>Z41tw56&HSI%^FirJQAm0EBKV z-kfX3$W`SK!eUAq`AuJ;JJK&vztcMLUwDla#GV z!OG%sjvcs*tR7J518k;nb(%t6p=5y8245-O*gJ=_DJycs5%)5IY;x_cT~S;%it)^n z6&`C_i}VK)=fT=|!b=-I^E&6mF=+KF=A#(tU8J1dh7%nob&Eau1&)C_!0 zl4pEvYsR5&NH0*-*0H&Lh0|xhh;uPv|{sLPTAt9_2P?_sV#Ad_H} zN02)FGQp)ogbpZ7NmXX_<_?m^j^5mHHaB)TfAIy@*VlRO`O_d2#}D=>cDI;iC0S{a z+GCv7OlK2nSD<9G3ll)Uy@1voX8D9xFu;`(YX!!p6uIP^-}3Ez^0U816iDXhS82DF zxp?_Gd^OM9ppWk?S1)bgg_6zj3|%U;2bF;|&Cne~8aHQ7DP40?whB`~kyK4gl><)* zgbC7aSkt}dtO`JI9mjaw|%yyy7 z8oi~~0xd=>N(kl#5pkXo zwH>X*EkQJad;Z<8kzzUd*weWxB^ zXZteW^w4{F;mnixev8$)159Tl+JhEvd*>r;O)hZe%vl2Gp*)EahE8;VdybxBJep7x z7Ns<$nR0pKc`!b{A3*8QEsGO|txdyV&}M$#vAgSt#}@4g`g1-~NwTEGna1_VSVulH zWLw~bgGE6n@G-7tVDEfpPQ)4k?=uW+yahY)L1M7|ZIareg)^ zBu5KFr{h@G0mH(vv0G6ThJLT2*9%x21hfVUAuP%mvWcM8^GK?Uyf$c0P^2}}u|Wt$ zT|wpyLJGV{<7*blQfpY``-wYP8Y~Nyjwf>c$K` zz}7W>yTo8nN;0?LV`_^~hW;D~sYqufUdMdn9is!>UQ6fgb&r-;hRxpG5$;nx+~@|c zcX`r%U7uLmrn|}lg{%#dCMrnC*B+7X2f5c`ukPPFs+)F|`$5dQS4TeG+zpyW%Zjsb z$J-v|@LS%>6TkTzj5oKD@-;@U`#S8KLxkPF$fkod_H$zzvd-+*`TbV?8&+K_LSG^z zXdQ9a$#=6de>abx9r42Y1iT2ZKi=A*j3v;DZq)d$CV7Ptf)lGDQ7@#hDT(b+&~E;(Y>ktkgrF`gX`JJXsPOEb$y#wx26**lGNdQihih=jhl?YqO7sC;n2bRkUHd<7r(%R z54?ll|NK8?wq4Sji&&gnVEx(^vPp(tN37=+-OInj^1+A~&s}6=Sl|bez_Tp(Tg*k4 zIIeIgJRu1@Nf3lwn@urQK@d9TIw7^y#A(5`^>zN_3%^BH&yaPSdrmw8QZpH?kp?p! zfAWub|GWQlF7?iFb@L48FMpK-gHs$iaFPwRhV)B1gH_t|ZPu=w#ugxOEcBPT_r$kw z@xnQFb~kXc!Z|p8`*9w5;CuM9$39J(CbT0TO2I5|EX@4CP+QGx+AuqX(JXcYipmkr z)#RCFHmgB8{IHSn)K()m1)$oFXZ9^EBJk`i8W*_uh-V^KNdt=U&v2 zqjcv6h%jR7iN{&{`yV0y<3B_j`wBhdjghH%<(~1zWnO#l_zEe#TpP{@ltF#oU4>o0b%*#MBz!^9Yrt zj7yBysEng_grKG>9JeiA4jkP@a7uvRVO_kPHPd6q`Z#B41rj9$MF#n_U|u`ky4Yhy<(z)z)9mcLgzyWZ zK+)}bBv}QOAZ%Hx#G>#CJ1`s96se)V&}Mb<7%#6q%V@Grx7Vl8SC}Ra=LH-(beN;Z z@8revUu9>!%hu))f2dj9>2Ub)LBf_In{Bf^uj#iuLcbY3_B$b)Tf5BlJuH?aFPdGH zlZ;J)*DlBlOP&?fTPezONR=>5V?600y(ULic!npR{~Up**%&=bm0CJ03uqBC8E=zu zjXO`gfiw|J;+jab!3sjzrYdSKuU#fDW1^1F$rJZeS2gF?o}oY2rYut=hE8Xmt>Fl% zoA{>DjwPNpA;e(-bqUk4!S8B}%aK~*`2vT-3qU)GqtPdpMq-77(oh>sMvV?F%J+$9 zFdaKkic41w7Dtj*Ohz^Hiy9{!8<%7H^MbqX=^zn2e|k!uJA{HDaxBg%q!eUWHm*&{ zlL9x^)P;{1NhYHbp)^PD2pNrQR{P6bxttNl(C!(i1pQ9HwXHFE3Plc4Xz>G0ujf%@ z7V8vV=usp&#?}ls1ihYz@(i7JGtMom3Z(^73W~DE%<3k2q^&7qK~dM>1YuiKWQ}*N zaE@sT#p~?6^lNo{ua1r1N1nM(s0V-VbO z)wxxFe#H~Va2#{^Xpca_Q_p>tR?y?_Bg<@T6}-5eP$dQZZbYD=Li2Kbl%?L31FREj zg{z_5%d`{JtPUiri#1Y;CjFq6v&r+bL!n7m2Ko_C3eW_MT;Cnbw5h37X^{%j`b4KzYolG%)2TazS$ z$yCy@Ew(vJ6hNLDx>1WOSH8r~)&&k8x|1L}!Pf33i}T0GVhFo}WGcwwtK4()O&q`d z7|%ZY9LY4}x#z#k%F=B-c^XZyOZMO~K|<1l+8wLtoa+A$kfbQdI2LRD1^<~=;^ zvAvVi>UgA6K^SPPsfa6sDQntMkJMBcCs{r0lgtW|*iz==hLl1h@P#B9<#;9{X!}$J zlvc8KDPj4bk0*SxJVUn)M~(^F?TB<@=(YtryP9d*7|2L1n2ZWc4N=R-3k6kGBR$K? zVMUfWk_6hmhjk^&bMyuw;E^X4?UqND)g+mt%E4HVy0C0bN(2rmWJ3Uo4P^;l^m^nQ zUd_aGH|_LpbV_?8QP&O-2M^)yeIwoXd@J1#em}wL0fw`Z&8;zCd18&rJ27ipGp>yb zCRxoet#BE3$|aklxv?xl8UaHbiF z-aP&kH-#PV2gv<*Rr`)BuV1#%TA1UTe&k2_roZ^Z3=SPe2LVs~&Ohh({`TME+RK+X z{@{Z={GH#$)zhbW@O|&+Gr#_8eDc?SjaIM6JHG!1_`_fQRfapeAO)u$d4wV_c=i*2 zz+E(wkBNhlW}kbjZq;j*j104Dmf^S}3c%MX7cPC8+YY^(H{ZQVuf5AxFHMWuymk3W9zJ>r-GlL{P2VJYLA1@jL}+*^zl-f@n}_VPgps5cj;fHvqQ&ND zm9yo&OwBxXouD<`)>f>SF}HgjZ$Hw*CRcdwg->;jPev!{V`=@-{yS|T){=siil@+0{=yiH{k)cQ( zN`mie>Pj%bVzK!*mBz zI$8_OzN^*lAhjfDS+cn1bAR^Ryy@Y0G3dRM3m4Banr<>4kI^z@G8; zQyRQhNogh0N=#vpUeh%eMPut$l@)CyMi`_Lq=}^}V6`q`vBqk==6GAlMoH)lm_aR zIlNO3(tgi-Xn*^6VvgU<`Z(t+7dH9YC%?$qjhM^Bg17=B6jCds(n#ea+RZ;)W-MQL zIU)SiY5vzAeiNMsA7uK}Q+V#{Bh=SSrr%?#)+Gdk7UAv3>7TkE8AS-sWAyxUY(4&E z>Y{w*sMR*8v!5U&_mFQtFuo$}b`LcDDB!z)?(cHvx4xGz{iA=t)fb-U;Hmq0@Bi>& z(#e#6_LCpR)(xaR@ZR_FGk@WIeC^4nvB0s9eUu;n$lvFVQ>XaqXFh`vf_Hq+2YKn4 zr#buV^Ms-y?99`o(T`o@sAFz*k+=tL%ew#O(css{e zjx*>)oE}cu8kfw*1_F%?;Q8zXXD_^wX&P|QyUL(baH4gI<#tSLJf7J;!6kbKW$6&p z3GsNIscI9aU8Z#h>uTCz0&~j|{W--nv7||X zGZvFLbSQDMq{u6}k%za~Ce3P+v_c1hEHCM`HQlz)Ffn+d@m{vZr{7v3&aU#*bN`gZ z!7_vX8+qpRmk_dGeomp4WG9|592N)_kym4m4cOK8}+Ck39H;Ovk&7Coxhh z(&`dB1M^9os4L|s9iT7(hICONa2rOFJ+ETh}= z@jZ`T&r+5!OG>iBQSWV-ibAlxSrK)bUAFeY3!30&9VoO9K_o#MYFi?;1t&2zARJXG zm<%DFSlS)%0!KEg(4IpoOVrkQuj2@#C9kc$6M(Q#l#m^qXYgI$L-^kJlzZ)*#0iPGp4@94cpfiLD%OStz5DJb?R62e z*^Tk#D`>igfrvA_Idv`*ZCKfi#hYg&hoPz;AW{WpJ_mwx>pW6H)X))~-& z;=s4OmHyrL5G*W`Zf$Yy_x=Uhc>D@a^8LVgeSiAk4}FLSe(;C*Ki>8z&wuT?W;*-Z zzf1qXK_33V2l?2~{H+_0dE%qL$LS}Zrmq@$_T#_zyIlEi|9jr`Lm%Sl&wq~Y;t~(P z``!HffB9FN{pP-oyzLtQ*cp(!CLi*a+~ZbVui<7)*cbE{EnXO~eJLm3ED(Oi=fCtj z+j?@yl`pEbLS_Fra7`DNlS^%GKwh-ApY|*T} z$B!J~jw5g3^5zyh+iM&=G$8N{qEyUEOB4mvm8Gr?Rh6>6b%o9C7dUe8VU}(?2_|Jc zDcRnv@x6pj-;l_XRtuJv1IAOyEY4_k1h=156tTbyLMj|ZE>NP0-7}S;*J&|W668gK zZ~;yTI`a;bHAVn|=TjsWPesH@McenNb;&F-)R|&#CF0_huX1HA!}A4U7yQuDpYQO* zv!7&naFXM<-Ov1T#LDU_k3aDVTm{4JF_GUx$rk4?y~LXzuGyKav%51Qo{o6*fe-Mh zPyg?I<}~m!Se*8QB4q8dOgj!U9i4eGmIs@xyAt~9SKaWD09bf*H9HT zd1T4f4O!wixZI)03&z&qDTzQZzocmOG-WB6O)b_L2J@OY7MR*01Slz}OGjNb(Njps z%NnI5Qh*Nj&iPsqwG~Qe#>0{h^$UkNqRAk2^!Q zvYd-sQ|`ax4z@ZS3l&lqU(bB}pqHPp~rYvEWOBYQ~{XhA>+UFJIv0e4E`#inI>neCl?^d?&(Hin{XX zv@62Equ-fl>Co*g4Gs`^15B-uGUxL4c``R+bK4=E&uxcp1t`SBWC+9FO;^NgOSv_!=mBqX0v@15QTp*v0D2>GrCBD*3CRb<$cX4F(B(^H3 zih_%m&hpKVypIdlzQp>*HlC+Z+TkNe5{W4#ojFT?pon}&Ja%}VCbN=cBJrp(zD2bK zo;F0GMQNB!Yl_0sjRY;{F)4D8Ia&vF+dfrQ6Lk~|y$;)(C0S9CPA$q4EU$FP3xgLr zlmexpH}KdQzr@A0=jqHTly;a>=Z1EhJ?H2FK1$iS@u&nksb^z9aM{Wmz-btyo!YS5j62AtYfW5K@sRpuHy1sj3}$X7NIWRDvw6SX>Q} zI7V@fvtX^E*AMagl6D^is@b<$htdWw08*?`!6@}+ZD5vx`oRxy^us@iy7O)x zTO0H7kDue|%QJRzN2Ppp&_ihtp#+ubaKMj=tALphIOE|-i!mWu#f@E#5PJj~0cfT< zY>aarT3Nw`VbhI?SHBhq*aDW`@hJEH{4cQfkNyD{e(4uTH%Bn&XLPr+725sNQqzx$Z5iX{0mR-VXBCi1k0tvM8jKY^@iBtq7FF z)Phzk#Fv(MCMdFu=U(_6SGHeZX>fvmcpHzLSRt+y+tZ9I+c}$)3|pAS_*x5`QB=9X zAUM+NaM0KEms)skj7hKJ7h5FpHqTtSjPf#EtuV?bZ22f>C~}99C9^uCDlMbogfQr{ zy!;?X4%|g$66)#-8`qxY!umR15Rl{K2K33)RiC}PwBLMB4vmZM;%7Y@{;kSq#wcjYCxxBDMo_f zcEZvzpS-9D!X|D<*ELaFBTI+E;$jI}F_>#H+AcB1B0NiySA>1n1WOM~bW0&4i_Mz& zBQFH65*TBM+R$ltsGP%ELunn(R&4KF#+VjaX=$}XzWn4L;zWtB6-g3v?$V#q?!qhy zxP0|2CvLx+_ME2QUEt)ghj{7br&+tW#_dP%!`2>YY?;M1FP?dx<)sx4&)-jyI7Z`j zin5|o0+d8pfh{aSK zc#&jhoDu{YQwyYUl({7c~_#{Fc}G6V5L-^=R%_6wY^eSZC4 zJj<8YX3U(2Q6Y3ZJmn*#rY#I{vB>uw{Ukqp-^cmNl}GvP+5_A+Si_SQ_btD~M^1kq zSM%=InJ}W6BU-H)W+mlH9~T5S+7C{iq`7&*#TiX=;lWu-#Ll~hHkSWaTeswj$Wl@&{o7n!6;Q5z|4 zAVCtqU>OW%!(jI5{cdM{w|qDaa6n>6*p7(<8!IL$EY zAbd@5n^eU$l;6hLDVtjxY;3KQ#Sz_%cCV%)(ln-S48b(uG~*q^xULAsvATQTkm^6Yu7IE#1r2@ zYDZZ#T)y%wgg~tJBCKGVpXSu57r5o7``NR66GEJ2Y3V4V$yG+h6|!W+r7O>{G=DQ! z)-G`Stq*eQ^l`SfH`sUJ7JR6vYR^+wzmBa0Nl#I1J8W5yrkbkI3^GquR0w4d+A&xV zbaX^MHjD~`&=K9fW`3xNY=^oqbi0Bk7>p@!ICLf`8{0B3AxXNDq^oI+$101;Bu&-k zpBm?|jUb6VN!L)0EJA9MSYoY1N+{}zsu3iKVzhG&e1bLLe8Y3*X_81Iq~yYd%S@&P zjhoO^e?b~$D4EdIFxr`tC99k|eTLP=BQ%9%JiW*Z7d&?yeFtBC{Qn`@ZP^$MV;XA+ zsU(tMd>|bNl33C-0Tn@2D2fKw)*9l}VvNMm#=*J9Qq`ccT{E3&7<3~_FBpw1%gZrU z;i&7-?h2Kp%pFR$;r1p7oRL`PiDE&V2%DW2~Xx z4n$FeuiIU)^%hfk(o7=>7*`|Y4SbB{bz?-)KzQptto+Ka^7#$NKm61&)@wybdJrcF zsX#=`$0fydfnR>tZ*Zh@g}v1peVMa*;8WbKp5egYGLf!H28Q21_x)U|=h`>03ydNJ zq}J>d4xh~tI$gpp0EBPxD0%~{AO0W<4}A|``|BUVO(!p@go1C=YKR3(550rc_q~s; z$G*XZkN;a-WBAg4`ccmQ!M{MpaP$X$kT?IgA7k#e+t_&O*mngN0gNu3XRvn<<0~5= zTTrqd-uHKZm1KU7W1sxQ%igQ_mW!DL{_Owy9sbV0{MVd0_5{y9_5@nC%*uv|Vy)=+Q|z!|t{V|0is0Jd<~GbZkaQfgG0aASy7VYnaCP%} zauK+)^9=cR%y52*L1&1L5<(fUw&48vEy}W>Xr^R+PaGM9bEKK1zt}+-folxY0=%x+ zw^uQnIu?fmdVS5M^%g5|+s9=!X5=tS~`Fa8@Yt-ZitQBqq)Q(HRefcx(H0eaao z)AD&vpZ_{0Y_o59$a4QZ>|c2!<b%GY+&k|Zekc( z!NPLJ`o;^~d(S&Kd+Ay3Tv(*38?H51P%;og!&e{w6RcG%%pc@W{`?OS!V|?uII#Cl zwzi)`s)&uPk}_yy1XW`&#$y`Eh4Up@PcWGCL|W1Bb=bGkqmxCPIyIxI5}MF}4a_B; zqeu4BAHbOxF7m?pyiHs|V{6Hvr!j@Xm6nCowrIC#z}0@&CgO-=h2Pzs6*I$R#}f$j z1`+wx;jCvch>%iI)PWEbNhV3OMg~n)7kJ%v z7-ujujmOiJhWXVFB(ODU&_W=6Ak756ZevA-Q`kyS=B)^5F4pKs(wK(1rPeN2mYyV5 zm|RfT0j(j5LCV0=ie_$6v%S+$*Osk~8F+yR7Gpe8C{T)~bi^rC7MiJVGqjU{GoGdZ zrEaie-1OhfJZ%)L{P<6Be&r_q_uqY#Yc@gjy9A{{N&=Fu@cfPapXYryKf-FdMJj82 z2v7;qy5O$PvtU7J&$ynW2`NfS5+Z8V5MD$zrI<8^5GD9d=Y~~^9$0wq!_;eQ%$_^( zl3`!>y4>`XEBJRU=RQ-CssX$=Vmbz}8d8xcg^+o;UpL&k>yG`2X>n zq>GC$LDG%DG3>IrXaDUV@vdL_RlfIE{u>_ot@gQZ`&&Q5T_5}qzx&ajqMViZ;BnTz zlqB$yBP6sp9M3=gIL6_`#PvpJ9{h*UCIh*%98d$r-v{@a-wtaAG7UotH=C}*(L&sdm` zxwbi?F*BZc`p>xSrhB;i4G(hj;k#K|zrfsZFH&^);^#lk*%zLqzic_Y?;##K^i~8@ zisBlZ<1vHbGKcowhM=N6ei+I1ezw0bOiGqjYe>JRJT2eN)x=JDJAh-inpHesKR5J z9ATffBT|ah zeFB7MFt4zt{aY5&qa%qkfk+FgDlnS`gmI*)Aj$$#*Bm;e$Y&87>lIl?(d)N24FpXj zG$Qge-r*`w2x8avVKB~vSExw8GB9rJ#=l7i>dxC)ec%E9^vTPtH4&oIgD7eXDQVj` zKCtiW{MhOr(@oo^ZEwIM5jG$zzyv}^AP9V8?H&j*KYjG$)P9kFapBz<-Oh`JRur}k z2zF`ul1lSi0U!YJ(h~XE)A*)->2cNVvG2nl!4^4B{?aed%x2vCYyZpcP!p2nMc(y$ ze?YpjhtGfXCpq_-zd&b-TYls}+6^5KFMF+TruVceDJ9_ZzxF?}|A7bi{*V1V-u+9z zjCT%OH~is${a^9SAAbS?JomZJ@z4I&N4a+DR2wbFH^nptc-u!lf~jl1^2txMX+E!z z;Tmp$c;EW_cpVg9o5#68Spw&I4Ya1nH zX<3+`$N8Gcv|uoID+?>nqNAFXG+}-&qizb;c50NEaqaS>l*OYgExv`tg?oAG#3Rhg zGxUcMhxTjs?!S#&ZhAXcu5R;{ul!3^_e5+?EAW!5EBA8$1MlO=k?&(LxQFwX&hgme zUnPlRlv-qadkcv`#u3HT5~VSh*Pq8{j4hWh=3KlmVc&t6o9`Gfw+i#a0q38undFX>n`5qS2nO>OiQwX8N2Fsq znZQO+*@oH&W?P=Rl5{$dbtJZi$_T0obR5&^1?tk0bR>HYBxo|64UBgx>e@1$T9j`0 zk>#vn%e0KH(@lsY+7=TL=w|KB3?X2QM@UH$3u3K6D`ccls-oKo1VkIG?Q@h5Sl19m zmN<$jW^I0Ipl!QQQV_f#PEuT>5Zbr)H{VJoor5@u5jY$Uq^B$$X+Lf+u(7}iLD_h+ zzDC6g7iuEmv9_YygWv^qC5d%J6+E^H2&>T{;GCns6w#PKIWtHcGEyw8Dtg@*tu)h# z#W{%xio7%wl_QBH-JZl-m=*!+1jD%m)7)T`y3TH6goULeM{$R4;q;$hpw=lmiU?97 zM7v~t`{D_H@$P?u8abR12rs||gbgSopa8E0qK1*2V{N+1$8P;i?pQp|Q`MU|o!`Wl zCr1&ot!pWr#~=w&{IX_@Z)0ysf}Kvm`*t5Hpx)fz^AEp^a%S+r{vUWRQmGa|oae5e z`vsQXd_Vu{?%Nq%UPl0X-u@8T>I(YO1>%06rmEU~pK7^WJ)JVWav5g~LV_)7{@I6q zklR1>A22v@fSpU1IrW9VV!Sm*Dv%n^KX#1Mj~(MhcM1WVgM)8;1H--h`0Ky$i+t|) z{yAG~n+V0Xd1J0;h9P|W*Ioz1*N?Y`;joMMj?y&Dt!OX`B^|w}DJmn)ZRgi;(hl#%L~NNU#eobjk?eSuxUY--ur@WC7B@RGH)2?0m16Y>0|uTho_cir)B9=!Xf8RaLa$_=D1xV68Zo7{l;!4jjb z3!FIj80Rm3h4JVs3>PC-_bzetraQ3plU%uUjzmArp@VPXzWd(6i8GH-)D6B86#a^P zmb0>a8@J!Q%>MnSnB+U0eEJ1~lhk!Z+KcgC5bFivD97uXymBb5$kK!Z`)+4t@d$6a z>s?%4JHzuAzs_tnMIqYel01+^8e=T=q#-y#9BU#KvAI6uDuMH7b|?zNZFlt8w?AWk z*x~Y8Ls^#uDUm7=yr4gnL<;iUQyNF(S`sqogHY{_MwBRawk?Q&6bje0wNlPNx1V6E zK)DawX85_Gx}=N#j)Ln=p-2*j=tt}1Gj zRt)DArVc0-QH%xU#FL`&ND2|?MBt3Zx`xJBgiz##p{(2Y6dV+#Lq-y3ps6CPx8yU= z+)xpx79ra`YEyZfhh`cO)CeJ|6G1P9d}QhBmXPFSgOUO%V}e!05s+$7G27#kfJGAM zrZJsVk(VV&5)+iCECRi*z&0N54LbF0idm3!I-23U#?_v*6Ua+}mJ%J`z{mLXZsJS? z+<*8m6W!xlZXiwwyW$cdU_Poi+*wCU(^hcURy86Uff)(bwAZYnm0wq`H`DH&NrU;C9HG^C24}k35nP0l}-KEJ)pAey6TJ;{JizV5f}q|-up1o za0sFG9Id|VJrrx#@TQ@+GSA}u_jCJC{U@Z0iyV0O_j2(2-piR!e4NeW&#-;!BoT1> zQ-93b@#9P`U2I>fP0Qk`Kl;QsRiUD-;BqfElIZq#cYVQf1HAXAKFT})r3JSG?#7bq*uqKt{UZKU92$F|X2vb|}{XO=Rz zR5p;L0_g>N_72#$GSAl4HLk6f%r6SM^AR$x&^<#`wgJ@3^D$b%)}}>CMH(v-CCNGw zlYBN&=TC%>ePEoA0 zJ>FonZP6(V2MO9Qa{paFiU2Bco->y&bMovbx#PC0yyeXg(;e*NYsWsrkvs0<)}!|@ z9gp~n&whrDos%?mm&K+1eDtUOGy1)K^yinT>j}5tbRUbuJ302upRl!c1tHq#v*r0) zdE~2qN?DH>_6}g|l*zWI%3H6TD=k84rqdd&B~@(*L7}u{t|J&8&4{xUW8nPxG3PJj zY;Bcv(+E$@a4th>&-wE+vNR!%1*7c>DHKtvP}0-w#z;Ia2y_xr)q#cOb}yXgmfS$6 z*VaOfMwTp9Y_69qEybj%WLCB+*WN%fm`iAkrPGl_kwJC9&DdQlc@$ySqM!)g;S6M% zMoL9hHgtQ6A{QiyV{tKJV-2cV8xk&qC$C(aG8Wo+IcvdLkMxSBYQx`SEpbkuRDzU- zU|VDUXk6oMASgkc3A}Hw%hn3&9HLlYokJ!b(?F#J-9+OG$7~9{uEM(p>mb%1-IesE zLaP{42W&7bEyw77hHVu2wqvr>V2VJJq*x4T1SAUKps5tDmN?rs)XdLIOf50Z4eT0E z_1X(|FY0jbEjMvxt6-}NEsGKYq(B1qE}r8JowLmHEe`5ksno?v+EZA>p+!dc6wf8xj4IB}d< z!}h7Ote-p!YPV@*S3atD#V=0WSQUCbyNiKO|K>m9i~s5mdH(6A$!BHzGsAZWxo>SU zd09^E>)`mBJh~I%g(Wf?QAyS=85Z}pp2Vtfcp=yt6^JCTv{#W&1*U1MeQ=WL#Ih0P zEH6j&=M|G#&9LtfaUjs3RA8E0y1Ag&QN$~0+o0neDoH_URBUOCWqZA$H`o3_CP~7+ zeLZxfD9Vc96urzdnjB}ed5r0-qSJ@PrIc%HWgC^&$=GusV^%nX6AXG8{a%OZbPL}& z_8k~djTNU)Jc|pOhaUJaKk%-fW@oa&bEm${bEh7qtYPoIRo;Bh_pvZ{n5L=tt1o?q zYnR46_`o~4`QRIPe2wYl&?FjWY;k=?n!r7Pu-w(ONXhsiT|Jp9Csdxc;-aSpc_+^2AZgC zAzxma0hRC!w1NlYebRZ+6BeJ%3e0ME^+RKlN>+( zb)+tsUpT~VN8Z4lx8KbqzsBdj_(ud6lcbsteE$z~=dEv{sS9quZ5dgAST<>`4cjBx%j=rdH$=!4)coixOYwXsPhV zgO@FcWbIYy`Lk1k6V!EtG3|cE8c7^QbUGC}@)V^($cW$^Ste1DrpOIhSD-UZQ#*<( zkY+LC9YYki4L(`g=DQAwNfW3OPvRub1*%yf(h4agN-COCVQY_zK?FzE(ReQ~*5I6D zxF{*hfH8qMiD-mtE6aA97=#rhQNVgn6t{Mb;5|}mQ0>0Et^@hZ&>IMx)kI2?We|5I zaU9bWb!&SQt>17qsR+)~n+p^Lm@0q>IOkz1sb-F<4rnd#A>h162uBm3DLttY$Ph@B zM5mIqjf!L{kirqI2oCMth|4oXkS9tQ5|27AI^RcQ3PDo|=9eU8U4sq`h6*VnJPldw>1P`0Ji#_dBajBBm22yzT)>+^>^)13!aKz{ zH*9X#%tnH;c65dsA9B{W9wFG{EY07{p(BTBTnE)JIdS?MoP6#Cv*`v$4&BP_x81|R z1GloVzRuSk`%|uLo*>Ul?!NV5zURUBGdJvT{)J~b_QY3d8cS6gE?qiLoM<{(m)aCK zZxFH-u=oIin3HFoV$aG^E?(Xw(t$M6WZhQ1h?5NaDWh@K3O-83XuD)Ml$ct9Py}z$ zsl#YU)AlZSy4_Y;^%vT8)Rk)`l2-iE>m(#vAXUIe9&0?owRxdQzifj&>WElNdV`1} zZz%KD%eb%@VT5Hevsf#cpHGm$_6AI?C&>b)woEoX^Gh*W2fVKlLZF01Cz5>Bw7XED zQQD&;NC$%604AG?x@ePqY9nZBOK)D&8we&l7E>#N3@GK1vb{+YqGi8PBuINLF_}#) zje%Z2B8w&CylR8HX=|&z1EmFNDu`23pW_>&h{ihta@RxRnOcVn?dnpA>wJ~F&|RH+o?}1zpL6d&{%vmm*x%=tU;Jf+ zRG8_M3%~z+ochPV!Ssa}n4CF{ZJHLTBs7!BODa$yzgbHq!m9_H>jg347507M2Ev(F zGxogE&kMYA``7Cr`C286nx^u^8KhY|TJs{oI7fewP!>5=>6lv$U=+dy@DA4mTvOs~ z%P6vuA(AWZMy}V7lWGUSMNSoFv!^rdthe zW{`_1rivJkt5&^k3|e}O_jCrDVMl@qOmdHi74!2kqn(-{+JJ$k02dr8+Tp_G$0)0d zG~O_6MvOLR1h>H3-}(V=zx9oHU-Q&6U*PQXC)wKBWNxX$J05%=Hy^$a9XEXW(NFXI znWwpWb;N@Ye1N6Z4)@;sJ#>3rI^8~N8<*JG*`YC0Hn%Tv;NT&yT)9B6*Jm`jz}(z^ z#5_AWg_kg^C)a2&9ohY7jWGP7h@T!aKBVMKfut2(@Oi?U1R!*%(b*E7b2M zh<-}3Q_$@Td;xV4s0$F0A?>xc2jK!`<*BNG$1%5{2thNQG@xPMzLaEd!fe~%oncx! zhJ8hF0cSl)Kj4EWjUv3PK`5l~t)-)>i4#FFfvh8_3fBsv8Yrt)2o}e3x6wo(+%9Pd zEl^4&ky4@~i&l!JcC9iv2)uLjdNDpgRa@{9AKDv>B+_KPR^W5#azmP>NTu;XfKV7? z2@zDb#!el>UW5&yogmoIGT<9AMjt>$F}l-da>cf9Qm8h|rK_05L%zKBHttGKfKpuC z5bTT;S=X`S1lP6&jdcvWp5;iOMPPm?7_0(m;EI{&C!YEkU#S(&gAfv=Kx={Yj*+p9 zLu&`oyFws+-G@?8eCbPEedw*Myz|}k4j*B9<|N}MpQPE`Y<-k~&5Li2WW_7YK3`#X z_o^7&tN7j*zb}Yarz{Px0zh8}!PgH!)D7e_%XnhRGJ%W|W)nvUf&Q{$x-FUH2IB+$ zG-7U$lAE$sHqJ$K2Ac6k$+buQ8!Yhb$**wc z`6sFJ39-s}_j`VX``+|UE?j(p^^G;=2FrZo*cTAeuy^Gk3yZf?HMdY#fxrBVPqBaR zUN$DDk#Y`ez&4)gwj$dbk##hpGITp2rNakHk_rfly0H|afL1ZfO9=$Y&Lqd;==TJv zlQ=E$PN4A+d8*t%El721jMq_wiao+rB-&Bct!=?O#UP9EMME0Fk;5H)6>)82j1-cU zl@yF*eQib*d3-0(3yv()lzBwA1C6bj?ogy7L}D_-1Q_bB05 zSaI~06r=TKmsxA_+~GnX9RTdAQs=?DKyN5eO5ky%9gVI%);46BqAoqNsi$fnNdxl> zs@+Kn&u~fMTwr_0u(M?lXwpm*MH)}QH;|W>Bo+u2C~Jd~0-Qt&fsg_j1oM4KQ8j2K zaYB<9?I^aMnqAS5C+i6EN@E+CPAzfjX^f{VB!m8UVT@6d5@mg6W(TywOMy^|ZVJD3 z_`l;;PT|HeNe`}G#bzE+H5EvSBSXlF$_9??3G7?3RI@P|XZiUzeT*-B^|wLS zt+2&;vRD!Y#}jqU;}#y2t#BpU%^HpP=4TD)>5Pp}eG0joDJsM_Q|6?&@k;KMaP8Hw zxf`wgxPe+Ue5Y~it6+WMbzpq`yu!)zimDVy)tb(`149}MrW1i62jS>1DXj5iivsHn zRW9)k%9$nYNyeLk#=>HhVrqe}1#zq>bH`}n=yWx62Qr#mGFvlDgC#hNa{>`0lP!;{ zVK{8Vt$iXHZNYS0F+cC|M0g_zvMqxZkweomh}t^5024gDEWxi7T$R0!>q2Xa&_x8k9_^l8E>tzvr%yG zo8HWQZ+w{5)jJqZHu%CLf7A*wyhF=~N51ws_8(a0z`=vubJs&0J$MtRPCd=#jgzb_ zALZCn-(WaU3%iNc)btj-wcR@*0NAnxa%JB|QSL(-gSKqT=>iDRiqu_Ab!rN%AS|Y+Ir@ z(8(fZxj_hlH!Z_!8qajw6Ge(@=BW!wn#M$lB`@r5&6A_s2~0+TI2Mq>!eWef2^(7l zN-I{DGtQhIkz}G(x;l?iin?&ru5L4Y33Pj)r9df3q#|tHs${GOg}^$G_l_uO|IQV# zxSFtbtt8I_oo+%tHB@y#DoLb0QVC{dAmo<8Frn9tNRn4p-{{R|ceI#v5OGRw143y~ z5}67XvcQ*j9$*qB9PVCZsXt?GPLOm1BEWpNLzecC!K0MH*MWUYmWLl0qtc7~)|H>) z?_d3SHtYhVQ$V#Zs3iSVqnzPnQSoGeC$C$`-6>iIc~HWTHcUGcEkI_wUyH(Ztdf^! zo?agcek1l4zQf1=U+gWs3f;}?0QuTJy>3Pn1w0MTN#aD4b|j{-Y^~*VdI~#{B$>l2 z#b_;Hn!sdanM`UHR~@!?7$cdD0=|}L6^OF%(gdeJA7P4yru4|vfp1l<-UnPA$af9@ z#v7FKAlk~H$&M#YEK%&4RSvDdG@88hh;D=gtnh7dt!P2HY8>;u6dx?5HK^D#n^ZKF z;=SMZ5suz;8_%71lIKr;fxfIMCJv!Hy#0X>arE##tZ%IG>A&~`#>FL)#A7PYU2nLL z_q_XuXzG%y8)u1h#s`1!M+qV2%a449o$YHJK5#2Z(xogMJ3Cv%a*l)h?!>z_4(vI~ z)6aa3IO#Gs-(hoo%yeo&29i`$*B+@XHVA@gZCW~Y1nH?O!S;5|a9+_J2J&3sJqRsu z7NpYD&S9#6@sM>TI}->ZkYtX!24e*MVPHJ6^i;;ef}}r`)FGkTHf(NH^oI(EC($uF zlFaggsOy+)2&|BFx{zfGy(q}$40__YdaXwL7&#EEZ&!e%J4g`HF`XLvy_7-EVQY_y z0##-3#v#2T?z9OrX6zUaI^=mEpH#%LL`aPbEnvnP;z&~z4Z`M)g+q{Lit&ym4}mxW)mKC+!WoNHU~HhSJwgUV6et^y zO2F2E+04`HbqO?}0&ya+Mj!=L#*s+c+*uDac2{rm%11vlZ7;z4Nf267+SWcH6r>rf z`GjA;{G)tt=T831y}!;<2lnpsEDa?uTnP*YIo&A5gn-@ILh32+f6E59?jNyk7DyRk zl!Iu-OD=d3pb;!&5z1DSMe%KK?8Gh_9CP2C`R>`>Kdy-OBLe!n(Q7>con3bMVl#z& z1(19xgY;W05FxzGCiybd3f~1>|9wF3M&r~Q0rcwt`Pw}?36!NlM2akmafM@h+z_Xd zxuuw9l3 zL2tg>mf@P3<;56p19d5gbxc!-Rus_*9Dn9dIC0|7sHz<46(VR>_uk3d-t~h_rzKx{ zg&v=Gm@@iI3I&Zxc8oSQWR6Z_Qb#D{KZQU=D7FXck`CJe~5Ry{R5nP;Z$oU zur=o{9-}S;Cr&=e@n@gl{x`pkEbH)*5C0?w_8;ZRr~ZoZ^eZH;4NcHmkY)l~DTG%z z?^x>Z!-Of$?O=_^HJY7GLs=TKOkupIC_RzaXeCLq2=AdOE8V8c* z6L{C=peCw^@dfKwXDloPlCGjCJarY?P=eUf?P^ri8u~*})VU7udyMXy3qkNH7%J3~f z$;&}8e2b_?dcWtw33DqE)(Aq=Di4u@rjabK_7KvdqZ)4{Niraan$fHxIK#o!eUzrebS%Dx(YB#! zYKDt3A~vK^kGU-4>gXC-3eGtW?uoEX!KBbA1#?Sty!GA>kYuZzJ$HgfAN?%Xu3aIH zQhL1@8!Y2-&2X4ueW0oob<-i~M#Ro=_0mN?dH$c`L&QCAd@FlbZvq<5U3i+WJ@zF6 zHI12aZSx!t-~GcB)r3>0p5W}6XDJ(yiNI^{Qj+u(x|0#9goUMjJoLa15ykNA$;Wu= z_@gN02*FVpOGp%vPz39cS%j?|`N)HUxuuwe#h9J#nrfnm`=Amir=IoA8kK;n9Cf33 z?o>^uS3%IN?V$^9XbC}3=ZevWqN<@cXu}-JnINw$T1#joosJ@12wdB&K=(LwxX0Fp zp~xGuPK-8|S!qc-FKG-;#bd@uyz8IK#FHSteI6&6o-PGU+!Gj@mqT+q~|rV@sm z4kQSf()0q2iMevsQJ1Y}aedn}Sal>lLETs;J2h!nlXNsv2c&|mt600-5N95(E9%P8 zA0{MSiHbbEfg<=eS*+XB2+=Sbdzuo`M4^PGtgBtoq$4;$C|t1gdZM-J?dHr@b?ciH zO59j{11%Ny2r3^C9fgY}JGsXdfm&qz-i3!bezC{*>p$kfE@G3><4&L2Fa7Vf6mOY$Y8?m-A1927Kw-m-R7+*tdUBRq@b@+Ciyk8j>eP@DZ6xZ z2g{7C?{LCVP1>>G+WHR8LT5pu`ht9?4HD?40TU$MG-7jeN@We5R6-%y+-{KCBeWu) z7^J$&6URS|7Xwb6c#g@AVP&~T-L&e;v=@<2YqqXVdG?vdx#vv}aqrzf!1=3BlW(pw z7%Wg4!MStiSYO}I;RAPY?)*uXmJTo;KZlMK@BE$*^TxaGVQuXSPd@u)&YgdXSfxZ! zLS7q;Yfz#!UHG;s_MnjT@-JoxLa6 z8q!1&#|C2rT1kWyjJEA=lqodUlSwd@rz{|r3Z(>28j_Cx&cLXoA~%k6kb;FY z@I!l3o?RQ0Y0n!LGp?T7qN?iu&n_Y!81MdjbRD|HyNt27EAA1yY%>CeqJ8{DW+`_+ za~+#}rOrlw15wVa1+nYds-pGM0p_H+$K|(=w+JprkjbPIWAs2OWF(cJAJem(Cu1|9K3^-J&U|>@i^W& zR`)Eicljuj*$&SfKL#>p@8T^S+Jb(TQ z-OdIJ^O}W0gaEc@7UcqU=?PvCyyw}I-(XU%aoa8TvTx~jIaSc;eU>8BI5sn;+nUA<(oI2PB9<+Lz=-&2-}0 zV%|L+l#bZg*yiH-9gMYD4{4@ote|KtX`+zAktTv{Pr__sD5f<+HV7H8uBK{0ClS3l zjnZu^(O};FzwEtvkR{o5-uJspX1=wyuBzUbS$bwL8!!MU4hA3zLI8yTO$C5ltQ+wP{{tnmgFVE4uxz>5wsLi&{R+hX`6((00c;Iun@z+EImC-&vaLJ zS66o}Z_nl4d;G`Es;;W3US}(jlM!#a=GCiwdGp@9=bZ1H^L>Qe;Xw8l@~rJ0Kf@Gzpl7;=<*el7eQ- zGb&0*45}2o3QWy5nO$r!E_$qA9b>ejnOP=7A+H=pD^%f_Kit41uzuB16@jD(NiqoDV0FUuOh(WZ<8eg@imB-gS85dT`ckV2iNaWg!XhCsJ7-WvZf+R0 zjt#GU7wC;c?BP(`@jr`peSXD#3g7uKPd@y0+H=1K^l{fTuTCB2_rE^PbC3NsK6&jo zXeK%Htv(y&R1D3u&@ynM4ZlAc@Uex22j|*+YxxRA9sa(P$7W1A*=BuK>L@X(4dG^F znbwi!bp4)|>o6?4qRQPxKH+YPZg!Q@s`ug6_mAys*B)Zk9OuNk=R{|Q_0AzwCnr0R zvzB+sB&SkC=KB}vU%E=7hRk$33`UCX;YCgyd5CWN06t6z)qtt?VXkhhbNuLoOmz=( zW#uA+!3NV)^90{!ZR08%{nu%?r%|TO()kt6p8Zw2b16rTp5TqwUqcyq{^f7s-58q~ ztkd{H5h_EglMz&`fXqjpstBk>SeVrmtAS!%(zl93hnw_zIj+z&+5wdq+RZlo(lbzk``cgUh3|Zujqw2Q5_~0S;}E6D8k#as>5s-F zNkLf#78Vzo?H=R72OnmtJ;T`-ewU>Smua-1)k#TAf>9cuI=pub24IXuYvJI*s2^BP zDzr6JxuZ#-tp%kGc^>HZb2?2>R#S?{T1BNwToy=-;lNym%_^>3slY_`9Ge(Yt65no z&?=|X)ih=lMIc)^K)hbmWiAhE)M znFgbNNtza9R^vUG#7Bl9mC|Wj@+!Z%VMKw^3Tq4)eLd->uW!{obAazOKM8X!9_}6> zS@;sYRG3c2gyRqJk5>LVVRC|BdgD_}+ab$zV?#)Nj_E|Pu`%RBUBl;2Ow-8{UVZH~ zhQr}|15xcVnh30J%R_D&z4=;nxLHS+JMxv=|5bZHvD@;M$jvKW_lg?dKi)rN;d@!M z8AsYf{7jS1bV7fid3imfw{nS2SOPobNIU27oMkX*F&^VW~AoCkSf5WU$7ys}mL%PI91=aQ@s1 zE;ue+d6{x-NKzeJw{*a2K{pH`H0TX_G#VwgQWRP-83(Rh@gx#^n3tA43x_nKP3%2O z6=^eJ6e?7vAQx-~&90)=4kQgvk(Ug|jv^PVw#>{K@_`{sVU#;Wl9&Qo?^9N*Tv{pU zbP`&P21w2ieCBh6(Bj1L(_CG>K(DvTWIV$A3X~#iMY_95E?B7}p+u3iXE;2+z`gfA zz{27QQk{_`)ATm3F&Vv#rX-&jJQFf)neJGUj^f(7;9N;r`p7Oe7p0L_Hw07D{8hPz zOd;YB4=&eS>kGz0r>ihiDd>QlW6TChf8j4&A#Oid*mn44m4V+7(*HYaIBf`zhl z6cZJzSEV3L41usWGs_OcSmzm&G^uNmlX`d8TRXfcI60lLFx}#E{xD&&%U^x&zvgG{ z-)H?$%8Lshr(wpFR_N&tvRUPVqOD3k+7ixes~X=(||H`YP*dSNYHfKS)`OSz5h7)(RYK&-3VmPw~>LFLD0$H|TAQ z=yWow5UIz?(#3R(2*&uRX`4eq_a#n-?6n+OTx+%ukxY5I)A2k+s5`#;E$gZI#A zHOPxq&YeHYRA+`m^KF(cz0T6Li_-lYZdKj!?5QG0mKLwmkNqfF+Xo;wR1W%DOD~E`krSg3_M$j4)22SA{5EpDKK%*;o&B z+ksX`V@;Ix(mF8MD5$EKqt1&!cS=)?70s3*Yj`#WjwDf3E|3~UNp0+#35gOUXuy*t z0EXZk?RMN@%ObYUWDUzW_Za0-0(r4_!^RefcVKRg6Q>{K#nlP9*yuqeu^*=j@snD? zbgEDaHY$aYK&2AqhA(k!-t$8K0IoKKs@}#$AW=eB1q^|Mt%TVuL4fgi%-OSN-?NDE zojPu0@NV@ldlcKq`^NF#?PyQl`i%X>|M~B-(yLglG_F`-G5;D}InSX(2PubBw3-tJ zlWTN4CrC3*W~V5N6m2zm9%#3P%J;bczDIcF)t6bj78r~!apcemtm@)*&Tz6ynR_N~ ziK_H$4A!~-{s(yA)T6Adyv%FoR#{yhkf=b3urVoVWU=&LD`>SFRAtGiADEwO&}t== zZbG9Oy~N=tFd0ErC@3^eIXsR=YOq-X!Qfqq&OGG=5@R@iqRIN&gjN=-P_JGcgYmS| z1g)F&M-}7ogoafR0+UiR9xE#6X*Hs-ZdnNZL5Vgg-ENn|iyy$MCXYV$I8S`&<2?8L zH+b>PGhDuMp3BQ;m|Hl^sgnZKcOdp`ACR|#1m8FX>FdVEhGds;Ep8Qd&!t-0d z{cl+tF5#R55weCMREB0Mq%F(12&BehOu(id@hR)86I`C zvu*NWKueSryRy=!)iF^~BY2t(&9URtT)G5WOWl%D(P&29T2~m9R7@YxIHyof$V&)? zBWqc#j>H1a4LPzXbf-1vFT(noMkU}yF&PMnF?6TE)Gz50fkqzTZ(q4fzpa$zmGBsgOC|TKxlLl#v{eXdSqP^pw$!_ znc>&|<>1B<?`!c6P&NwG_}WwFbRQ_z#;8vD$gelb(v`-1QCoeJpcUjoH=vmkKSg;t(kMwE+eY9 z{lDJBForwGU%r3*(K_B(tB}E~JeWR5%dSv0E%WoISYKP^+SRLk;>l02v@*@Pi!XA| ziDTqt&Q$Y$R(ls&x_lO^;p0zzmi7J$xnE|be~!8CJxq7!84d@$^71!nHVzY{!Nft* zbUb$Yd+85W`OPo?DoLWLCYB@>yz>w=hYl`+OejVZDktQ5jxhmcJyn%qt>yfsG1|cN zl*M_CHkMXLGps7Qt&GY6VwentnYoCwWX+7Lo`kyy*dYTPT+ zR3SlP`;CvH4YF=I2zjS5$ms1`Ikj={juA1SPX z{y@=cCLBMKLCEo9C<+hFsLWA0jnSS1^C^X^@Ih#z5V0tu(Au!k8#C4p6Lh31H5wl@ zgJDVGJz2{TT%dA7ukWx)H1L_VXr<^40}749;e)~jAB7`=P&!SkZEqei-h0nIeCFT( zVgB!PeU=JKyOlEAR4ApnFp1l^)zGj)%W58;$(U50%VUT1FYwXgS6My&!#qDef`pQ_ zDln&o6G`BnZo&s`ksjU_yrD8vrF)5wa6yx!TyeOEOnn9#s zTnvdRn7AQpYfu4n5(Q_qj&fH;?r<&^>P7ihRjc)As=^~mVXelw2s_zC<6S@zd)HhQ z*-VU4Xss|Nii3v$Wf?F=MFQ;_e)2w`RNUCC)hMNKE-F1JrKu{3^pLt1*sYmQlwpek z&AC99H3`8JeBj8DlUQpRjfRXT1ICjP5aHsv=~nwL%#XFYz2Ypol!CRppVOBiCq9R8>IPr~o7(Ql%wn5*y|5B#FXT3g@VU zn9a4U$ubSv5aD$Z%; z0$Oc8KMJek-$)%QL_(IBs#8QEWK?XIu_hv&J_yF>t^G52sWoxqn7ogF+h6xLjuWC+ZC3U4Y~7NDLe_D*T#aX&agThg04_O=%%nZouMa| z7q7$%QYeB1&cAVdhs9&ElpT1X63rCkih@RX~v1XnAN)MUv;>EFwB`ed=gHd~h@x35gZfdle$F`AMs| z`6r2{a*z)rGtAsvM(Hbx++$6GO%&siBWq}~G+{Iz5<{yK$Q<=F8L@cfzA2-?w^)(|Y-ZH`IkbTUq#eu#Fv&Bn$uVP2LI`A;L8GZkM_DS` z9gER{;UF5U_LLx!;POBS3egIiYLYDWO*T`5%`}5vY@SvqjMfAn?~`+ah{jl$naL0b zd66?cn^IMfPXcA-$r6o81VvP#*W~00cI0ubZEUb|LNd~i-Wu|HA ztp_?YZHD8VwY8kYYP6Bs!BJS7kR*z{h;0{1qRJap23t3$ zd#O7x&XzI8rqivI;*I4E ze(~3z;o8Pq%S%qTTYTZOALO2+b11G?#VBr233JyL>iu!OKd!fS1QWP$`Bkp;&S8v+ zWa4>+h(<)wXeB5E`LIG;MWbm+8&U2}T%ec)vbI4*MLWb(M^`16uf9rN^cnXHoY%Cc z(x})jg0_k(SC}ML36@1v`A8ClvO;hbCbMMLQ0hq6B|6@xauV5CLAlRUiqX6=@?zLf+R=gH@DejNZ~TMqFsY zRe_*{v}q~x5lPZzcJ=^+;eboa=W&%I2m~Dq5v|p@QX>iu9XiTXcZSLpTwcCZM@gEZ zP?V*|7-(iD_Twps;Bl29A9=Et!lseawJZWj8uMN@(dasHqAes639n;Vqj1h+jF2=z z2)L@E(KTojwF}1siH?wtQI#uW(nT8~u`v=Yswf<7bd3DH4+MlHlbTLVav982Rl;-lm;{)hAx(h)wDdV+OZj3P= zn+QQXRb^--F>EXfM^Ok#8jWD6EFK8B`22}NLX0Fugf!KZm7r}zF%(ieC=q(_E+9CJ zQ6x4-tj4IQ97VvU_U4AMsw%3oV6l;~U~;U6Yv%A`}y79{aprw!N0TP`lC8uZ*^R^dziFVy_U!e zX)_fY+o_|&ykb1|jQXD85ZaxnYAykc(d6S;#G$mpCQ!M6F`5n6!&R{l&S--V3h6_h z$4$~0MODULLYqctt;_>TZ#GH`T1N=idypVxElXJhjEP%NhFQh_u9U&KhpdBu3_Baw)P%0-n4L=Y8WRTVK>l#bF+k!(P4UQy&Q z8OLI#EQ{Z%HB?o=4+U+6sgA)p$V)*yq)9~Vf&@Z{pHW0;Imr~J3}_{|z?PtJ){GSp z-p4u5^C%}4A!Cge9bs9oXm=B;!m+X8v0CE>QG{Npc- zyA4U}g#Y9dn$F~9q(9z2Nv=4Vf?U-gbPsJ5-;&9%GRH;%(nEU)$XH^1{Nc{RX0P@-xmKRRAP zgv9Dw8^+;i#KOV?hnkx6{Ss4_v<-wx@y-&I-Tt|yDlh`+4F+_3-=^p!j!^miHLd`i zR>pk~e~1@ecs@q)Rdw419Cto0xpiQ*XGHe?e7zmxx^2h67{r0-Kvf75A}dSM(Dbgt zU-^^A_?bU_^v%)qoABoC^RD)u-`zp;&D6U046qfG;t&td^!OY9*I8QKQ0FuQX%eGc zQ;Vr8B$nGNO<6=}3=u-`Ooo>K?9<2i=^Kqp-Hv0UZo>!Km#~5h4kJQjk~} z_Tgtgdzhd3;kzBz-KfT^8?Qs9nB<3eWUj|w`)6lpwE{|Fgj^PZ5CT?fw7x}-(K*L( zI3$Sh;rTXc>Uhqo8q3{Jr3eu#f6K9fu7i+?RJ}XyS;^@?>^?|=b4(C0$?y0 zu(q}qs}65_T=fTZ0=iZ%-M)#2O^>ufxpJqQ{{DQut>e1gh%tniBXgDD3aH9Jqivat z;U_<4_FXjnXPyxL)-M{MA~6OJbzU$+tg#TsV{}bN8FUn_)e0Yk(LnJNAKPCjK`Y7l zu@4FV?Y|lmWCjTV?<1>?wU%!C0Nr+nqA0kue38+3K-Ms%O@;HZ`Zg~Te(K}&c6NXhm6Ce)6gPH?AN1knmsr^8{rp zT3NzqZ5M|;putrhtuk$8&)sxf3J5x-*L{+g%7?hvYci?~RZy|qTVlnf(vT=cW>0dUd4vbMmpD59 z3c9#uOreS0K z7R5IJ>+9=Wy?T{{2MslQck|7PP7FfGi(KY>2{6#mRV$DjKZFb!050X=gcYVHH5?ny{HwZR`E!zE<> zEMe^oGPw$F%$*2Gi9qn4=U;eX+k4knTAt_p!5{nq&p!L?)_Y4!ORTT2(`YmzJQbo8 z&mN|Q%1m*g^(kH)KETzXqVk(nb2WLq+Kf=3^nubVMpc82@;**?+MEu*MYFtg#}n|* z&)0hyF}@p6DkMgeSc9>O-~(D|MnjKt`#GA9OJAo7LQQ+7HI5iLdKY2=kr&d;L}RF9 zWA|jRkH@7HI%|?-(I`e|GD6)tD7;ei2R&BTR?u3zbtI%3e zR<-I-l2Ew-s)mh?MI-;?q0qf@&YeocvSB@DlF1e*)F;den6%p88vH)fKhj z-}@Zm3(Vn_vZ?`I>A<2Ob#l~l|mIqfVi7C})|uu&K`st%>|Y>eSKe~7a6eLS3gm1h3N z9Yv1s^nAUi5#zfMGKMM=Feh2`+(kT%rl#3U7;Wt1Xd3Waj5mf5U_AD**AE|aJwBGv zS7jh=D0I+NQujLUQ&dM;Lu+vn2}0>hP|-+e6BXt!UOdlwZ#^0i71?tX(P*e!pdarw zs$-PKc|+xefFRDt>(&4ctrg?3L!rnT7NrBO4mS7mIt)ILn%HAmR*?Y0rk-Z!Hq$9O!ZC<@ls*I8U# zyveu(m2_BceK%(&r`gCO%~UH@oal}?rOq-}y+Tq>u1Abm2F*iU=seDAqXTSAgh>&2 znWJ>3p5$IBF_TNTjhozPzV0+)+U0!n8~42|)l|-7ZF<9Tz1OIY(n7NZ zqmjmWsi_BQBb-K(0izAUM|!sqJW6@8Mx+Pauc(d!OrlU)5qxyaL?DR2J=rOU9H!4d z|2!|h@(Lmrkpp-1@C!r((m4W2T##zBQAZ?J8Y_kB9z%6c#BM6Nn`Z1cANSsSFONU| zIMdV9w>FHz9ydiHzQi2<6X=5FUE{R>7LDPHadQa1o}(xWG-I#O&6b&&{us~dldKMfaS?bWKh8|{ z0P~Y8D5>7keBIHM?>S#L_^bkzO{3DO7_A)p1gf=g=NA$@;o5ibOTUMR-?QuCU4c?1 z)Etl&uL9y@vo(>b5|O))rWH_D6=C``%@a?71oHD=MGwwlY;xDv9JVpwZ$kSvRZt1} zxTb%zksH)ljjKFm5jSUJV}v665!I2%8l-hiXzhf-XvnqIE0NK~YDDR}&?dI>c^B|H zk`4%AZxn7HpgPV8!;KON3X^EO2;OZH>j+BMk)r}p(NWbx?Ag?E)A@QYBSx(?S)$0t z6$(X?MoPJS5^(-D4ddp9oKGfL+pISlbw?&zbQX=G+SNy;)O91NRP@AEO%Qws-yv%6 z!5lkwjBd9}S(ZEA*ILtPG#HP^yUw$#VM_#T6Lai)&~p#6T|8=gr;|)p3B7a3@FFt0 zQbWWCQJtgcnR`)CnGzkyPZ18}8nymL666z{4ZMV&pfGg1c0!KoH z?|dKM^7k^BIIfN@OXet3*&=Cv=`GFI9UI5nStBB-<~;WFk3cmftiOVN==13LNA5go z6v1D98ozcHhL;hocSII%*SK!|NIA4JvDqArmw;%{Hd4z3FL#dW)J{`b6^uKN(D~5M zk=*zFAVN9&1mkc1uQWz4W0Ul*3Mw`UnZHGE(+ z_JoiS_93bxfw~&pG8}Bs@AnvuHYlnp$|ohUPR1sxrbdfJM@lzIlYq2x|wO--?~vcmNA^w#_H^YeW2 zlb_^kU;Ek)!?@?Tg2ya8f;sdNNT;^(xYkBd0y0>_z51)TbN?Tq|3>6_0x%hR`V{8) z_h3(a5A+-*;!$BlW{4fc3i`yOP4ry>=>W=)TbB>2F%RN z(Cv1qs)`dQPH^t^i#x`pP!!n_u9baaOb5MPq zW372!E?QL1vFwj&FAk;#As9SK2TLPX|fkQLY7`{bGWmIR3QX{XeM(Xqy1e!L-*eA-ExlF5B&#( zq)YFse~;GSIU0>7ccbwlipW`s+M=h^CRR0uDsIMA=3LftRNG!B*F4E66GD8qUK5|>?Ao~r~5rI%s;fXRR8+#ay){!z!-Hl<~ykU0& zrHVk>MRkr|k3zO%_?r=%T!*`NR6J>Z2MHiVec*i-gPHAbIpJV2*wQm9(QLw(vOS z-XFwYdmfpr?S1}T$MW(rBEn=6>G;0#m9OyVqmOd<@L`(GCd^aZYy2XFP{Y`_vS&i0T;`a0fu-alR6)@zGbWvBX6^s8$`Mux zc^Rd2462q1s)^6;5Y=%(V@`dB*(ZLQbn%hv_n>wpy7zqwm3Aq<{SWb1zKT}ij*8?q zDZLUKS$kX+>DK}Qr6Fr-veYukOI#TXbhc>Gwj&<<4b?#?%bZa$thqo{lrO4#F?|rw z(cxTNI7XUgtgWvx8VxYkkQWA_wf|6^`dW0&LmRvxUT_2wOU+uO2tORn*HIvfe%7|XLpyG3s_`5fZcV@LTVZ9F_em-zCHM1{E_d*z5H(xqj&t>jSS=R^78c!vMBi0x4!kJ&prM0 z(>(q3)7Yd1bhoiwDXO5D_!upwS;CyzKu@kBO5O67D>cmqdFK&4Y;ANe`#!+#ECTQv%CgB-XBQue8y{U^xiGRYHv89jYZjgZ96PQ5M9 z!rOC1)c}nT4r?Q6rAX}e^X~Rh9aV1<6$$#jAEN!_Uqw$H-~3IyFPkY3lh8T&B(13h zM!)|LaButuM)_ToVmC(#j8S+Lm8)c@#c8O|JQ6yA^knLMkN9h>VM;3#64t)IChgd`v zJUA^RX;lC40h*ny5|Vw1>WC^cW zg4^?jGML2=qO-Z{kIlAgi~EMgU-<*vtG|YfuU_A5r%zxOpNItkd*0W#D=D>&MmY#R z1Vo^jf~mtEb({Bk(-${d$gH51!h1(qxjR@JZ{xVOy*B4mHRs5l_)8>@{CQN;x;}Pa zd)i9x7?1c8_xcwppZf)>v;Ugvg@1t*z3WcS_O-Gb9(pInbsPS`cw8_kVl)xF)GRWx zWf+v){IyvKlS@jt??;&W#LuIrPV6v>Y(n?4iJ)lA+-bU>{5x>!2l3eJLdUoIzHLUt zCYmg>7;VrBnhk@}n$f6=0br(RG~*nJSNKiQ+8yKCB#gd8R3~3Ys&Rbf>x7kOsGj-X zD4+g&_@ysL2daKPH&GqcJOClwcwE;rgYll}C}A`;HN}GuK1Py*fw z(T^In+=l8hS3Ub z14?U($=yP!cenwl+8Ft(&*CqC6FqYplIG3`r5xZdKTTMBiEVWMcb#LLo0~&K==FLm zEG+D(Ljx9+MD4TdAp3qHXxs9Km@55OSof-ip`C46OWJ4OW1Qkzf(EJz1LwZT1f8u zA+WxWM53XFXU4}O8g@Bf=%vMm*KwJFW8 zEw{b3rHDec4l?uUzst&(x>PU!5)EB$ed)~_9YUz}2NR1j8f84ed6cmvnL)&WsW3+4 zJ){jqVl0!wQR@AR>PUbp)Z)W{vI&a|3nVsU>Ei3;#Rv(Cx!D=!W*3;7JH%kH!Fuo7 zu1#W}p*jLZ=?FyV)Dt09YojQ2nF}gtl!?+!T5F7{_XXL%sE#JCuhJDHsi}KpL!C)c zZv{%dQ~XFH`3C;Nm$65mg1HBxbW06&gpF5l7rugc7sKZ}J-@02J+~RgUawcHn#&Hu zxL3ruwb*ySFfn=TuRKdwd3M)^?CZ!kPKKxmXQ`Xr8*K?2uMw_252ro@Hj97XK7{TZ zA*{c0Juz`N$=qAbm+b6+(n`pk;IP*>v|HZyy5wAe7fs!W?;$^dmouJM)W#tAB{H&FD0YmZ_fq zXXxpBF^4{K^ZW8n%-5}oZ;aW3Ad9lVrh-9J=25FoZs4G7w<$y4!hhf=IQqRmQyWF8 zhoWx2?W&qJB$;C2lYf&HEW@+EM8}M{rRGlUwQm*;X#{0-Bt<7er@oZf`j0vQRgzP>@Pw?U)Pq0{Y>W+~&L+!?BK+Zl$Ps7|#T)w#XY zGp?v$?-1bz@X#$2G)YzN_)xS{s^KtER!1Gny`QJfSUqC6lXHmut?}3{j<10|~z%GI|v2w04{jP-@ zRzpKah%7H1ec$FlHjU2LZtIa#2x1zH%`C$rQbJ{^;ayN$x-A!1H4mU0GuO+t>j~1+ z_h62F98i?s_@4-aCFIp#L3IwJnsZ=VAhAJPP=u9dshV}IhuW08%>Z8$~Sjbp7#n6y~@lm8Vf z?ZZ@Oe*rtW7)6NR6roQP?fIUBh{Wcqy2#D zC>8rJy?68nJ+wBo+8vG@IZnT~!FW8P5*G_~oKW=p495f7twzjV?Nd}I2vlV(uG!q) zVlTCjM}$Le2|Uda7(Q7 zPGK(*L5bhH%18nde2t=RQ|Y{eRgk19%2+y`F2-8cH+nlF#LdI`SZaLlz4tORJIjFs z2YBIym+N)6%d-d$HFF=y2fl!sxhK*$ZM+sI@alIEV|SoBw=!-5NI62v9;!KyB5c-v zUH|UwnEBgM;km7OI0%^xm@+-CsusaloGXuWsPiE0{P*hbyY+o{$pV+`BaCA@hN+~a zDgCVn`qsv-^Z`M2udTapnBb0znKKVB-`ro_8Y3RRlTVQAr{0fU%5!5*`V8=qSKzC+3GSL z4H*u51Y!hfjbW-g$FM)xpQuiqgw`es`c|&~*(gjcfLzt;AW8{J1{1%i>(2W`FeV@ZDJhla+ z)=2>L{3F=YKZL*dwa8fEt4(&^+x`}76HXpHNTZqJ@*Fc6(gYGB14FC6KYB7|`Hk0E zIC6w$Vp+a$fyr=y$jsj33T~TFsX{eoQOVSni0Yl~CI-Lq4EgWDa$zus^8sZN7S(y$ zgXik%ymzU|eGf+_3JMsoP1F`VQ-8i3Ql0%bxbt5^ws27cvP zw&*;n5&rVin1#owR{oH1^*fkTpGL%A_lVzv!+EeeZb+t1AryH4!cCOk1$2Tv`Z1hp zP+fk8Z2m!1(tHa@wnC~2#kH4EW*W2jLFm26nWZsPEyI!71Rr)@LsbPdiZsgXBs-~<9ib)k6 zvm14X*rR&q=3^TT4o@FM{B`M=TY4>$v*LS2x~7={^38yKm8A4gSgUrL?7># zp^ShLv;|rSjBYPl8+tE$2q}82SD2!RHZ&-c6sHUS-ffCN_Tq^ zjR>MNx^sl&p&uoA@JHhf&=!T+K_V_&O}rLbiPh$m#NPFGXBEvY*htrKcA_uPwj&2Wls}u z>jE4Rn3}xE{nIDu`w!3?dqyQZw=qY*`vcrRf0)_9H_>Ik?w1m@PMCB~^LqAiUhU7Y zk=MGA$}pqX=~fp};@H1OjP%pf|6biew8vU-%+Es_xc03ZNKL_t*l zTWjro%9QkwOh}uAAP@qCgkA(fAPA!1tN8j^KoAwIApI4PDk>I0MM2b8@lyc{B>^E2 zdIrI_JzJGf5yJ&ih{9xh^g;?VP=KSZ*MW(prQ` z*wVO}eYy*ZR?~@ED1@&?ItR_x#?AC^T7Z>-8{LtbK|{yVFlrKinfDt$cUU`_bWnaL zTM{t{lye8M+R5G}u`P>C^gvX{S%F#-osWFWV`p`Kg?b9-&Oq4Qhu}v)`gv6>8 zqGBMagFlC;7(o8@A7UDpc4i%QmF2||CW+C7Jf@||Ekr=u(z+5n(MkMd+s6C0>k=+Y zOd6LHG%SH(Cqh{1ZvK4^BN%!dx}gq}ld)DK1xz{fZ0gsH<$(t;=Bp#vg_jzP(8#x>eHp6nolRvB!PAgr?$0o83G z?~;Ku;i%II$9&Y?q#c|4yU-vN9WvLj_B71a#T4GYw>v45 z-As(LyAn8ZN2uJ59UDn57R+xOfvAF7@d~N7Rjv=c3o}={UkC08bS`G7z6w$yen;wp z&C-Hi_d2PupCdEz>s{KOS?{7CdW|4`;ZV2t(YwTi{q6>69YUhFrlA25w!(xXnJyNCeusIrLCe$2m<1Y%yu{cSNCJNu>or z;GHzA6V(=8$l9?yb!fu&SW!KcVAu(W(rncGk@+vWZYY8glZaRR z3tj(q2`cFlQ;#F+7cMLlTDPgJY{z@A6E$cjFBPIU%tEhw71d`HqkEI`kq$ zs)}UoYuNl2tS*#q2;qXA*|G?|bqQ+l;oC_ZS!*$^>q$1v!xox%D24alC7X9bny{eq z^^B3v(XTqkqF^{1^I7sHKpSV?S*i>L1WJ-on*Nyr!@_k$T2PlCPIE!g775;M9S)U( zQI&$QZRK7Ij@zCjyS?)It{sDr$aFQuwM*5s*cr3Q^V*ABp)IMMc7xb-L|&|+P;l&w(zY8moeMS)sKN;D3WY_jJCc$ie7rlNaV4T{ac>kZNDy zvar1v94*30?iHG$a?q}yi%ef+{{x8@`~|&vp{p!?q9?2NA$91*2tPb-b6bg*Jmw&u zwhiw|NPACa0EN8v0Yf-)i`Lkr?3yF?*eC7Uy|#^O5}P({V%4fuTzctO$*g~t>dFuc zq|>Tgbs3krM~S2UOX>Uxlf<=E1d?2^E8~Y-tLiHU3=|1njTHL0hB1j>shapr38@JM>oU84a zdF(t8b{$-H(7Y28z3E-zx<_2ezR#f!zg8jisU@u32et1p(7qYd?v(pw#UQ8{-~??` zm1V`J4r{ad&FJ+rF^$XJ!)I;x>)M@eoZZ2uCln&Ll?+?hH(k%*)FQM9u+nzoJj=)s z=w>HPWetH07*PRa1q&ESV?ogx2^KOGDvoA!7Sio2oXEnq51`#MVX(7Rj|+@?)4LRA z{~XnO_^zKd?Z_Ku>tam9l5*B)G^+m?!m;NgQlPgkBAWjv;>C|Sw|7rS>5SQb@UL`6 zk}qhim4tyLicQHx*7EN)hLu9no-6Q=dvD{PVZudUxsla>o6F~q3^?SLt)w$fj>~9E zD&yF-#e%NLvUOt(h9Hm_qrgZ%_}(*7og!;hDN!;VR!VqLanBz1!-c}Q-!TZJ={_y* z38;?i7us@iWGzO!gj)K~ECv!O%Y~WP(Iit3Ky{48nP7us+&WH?6S?oskFg`$(Foxj zr?sXK7Z7R(`J=UnAcLr`={!fWyH$+=SuxP58$`BS*)6+E!EXnFW(QPm;YkI_su?aA z9&jFN(0D}X#ykisQGIHmPc2eAzcbNA=F^#?VbGi2C0YHVODYImYgJy;%Y zw=N-stL_*5jpV(2UI`j=avx<;ro;u!sD)(9e4@91MY8U7td2TlpnHFo(OT;_Ugvfn zc=KDsdlZfmJGt2e9pD$+^;0CaudWK47cylZP5*2}VbdaBUvBx-c;iWAqBN(dje{OZ zT#^%MfmH%2t=HtVWHTwWhMd_!-uiDwb&A2jSg=X?D5Z1*?KNEmP+M)&r4%Uc?i7dO z?i!rpCAe#FE&k%}?!_&*yL-_VcXxOH(tqa9Ofs2C?v2dd-E;Oid!D8O<8+4tdU4*z zIpB(k3JK#XVU|d7ARwA~n2aKeyj2bBdWWH_r%C%3s6M>MeZEWuOB+WD7o)PWb_dV@ z1t(nWS0a8oW>`XzV(M58Fj-7}?z9H)vFkY+=W{K?8POj-zxyVINj-#^6|r)GF}e6f zamJb1lIaPM%$Xmm^ho^V$`t%K{2>=V-1 zsU3bs^Vr=S?Xs}f6~Pm~HbbK=_ydHXt;x2kU5ef@E|YN`(FCjuGg?HB8YSFVnBM!_ z1M&5yTo*$5-L-I<7kLw_e0V>xyU`J8xZyRPZTUnM4b}4CdOVe&&WVi&~w@JaPF5KDM zJ%RyImLJ=aq@Z!Ig3Gv4jQ)&8aTNVTqiCII522>Ee0vvNe?XRcVu>IMvzt86z*K7$J6Tz9$>umvs zbK^k;CBL4@ppNuMYVvJJtuYl=Lne5Pn&vT>e2Fvd$%W4A3x~1*9ah4l$EkWlq04)& zod?b>@{lY8GL2(mBrr!dWx6RXD#9iXrL0exG0GwD&TGH~xrumtvz{!kljL|KsjL;O z9}m@0KBNlOR_S@r?{PAGvXHXP+VQ^^0_)B7C8?N{`1-c0!t-l}+szVTm^SS|!2~~V z8#*0H#Zp-*$QfG{9mg>0FrRg&@r*tlU3%LX|-Mz(|z-PZST-oHbAyLZjMv!?_fyGd{jou`-tZgy6kynVr* z>4?bFmcaSlSYR1V1-`Ly+-cuu-D(Pf;6aGrHroC ztDZAgXu*fqPZ5oDw#)O{`6F?tIO0!Na69-h{xzh8xYWlTaRF400o#KI?X>y)gFR8S zUUEm!@IzB+xD_l06#Vh{)h))0gC~s-DkMAwmf3MZ=s|h^jTn{p=_u20nNvp_wD;z_ zAq2lXryzp?b?yB~HuZ8hsXYU#KdJ{=!vezS+kTU6ZjGre zwDXOTJP_Z;)Clihjp%Ut2WdB)H~8a?Up_Z0E6JpJF&H%G-vVY@qE;D24qw~n^Idvv zeFc{GB8Jt&kblS@ppt1{U~dNy;<{{a$!wYLxfsh$iNyk3y&DT7C}D)tQPh}!0(am6 zs<r7@D^g_5*YvGmE8ZxXcZ@l5qbiJN+untC=|8MC`tJQ(_$NDdL)Y zj;$d?MA$h0`-A=zOt^Y^vSi+gx+=E+^j`I9#}~$%gQjOO;Y-|1SPKK83Lv^6^x4s9 zEwy~Z-w7At!MbNj}3KS7`;H9;&F5wzL4!BSc zDITh%T83HuSM2C45gicFM$&d}x&!cb-A{~a1r!iNwL;og##n=RyzX_iLL9ME8NI)65#o;+c z`0a-ognPvIJ%HozFHr5dMrwYGx)OdGT(UbF93UxZDaq%rm8HX8Rv8OtH|4+qR*ddl zGjDMX@=5b7lqxzZcj@xo%cu`SRHH52L08v8s-FZhOt4AT2Y@=(K!&2lzZtAxG%6v} zUO92*0B_ULI-#v%0rv01Q1q2%CXr@84Q6)clOs=GQUdGeRX2>;dXwAUUj?b zwLd4!J~NE*yMJcN!l>Q|_H^RPmV=c+P}yEZ33Aeq;ir~`#VtUot)&VlLW#pflfR#K z#gPTn0uZZ@7$Q3*n!Cu)67Y8NT=w#e(lG~W4{J+Nr6`Le$33;NB7_yPcm)L^w0z}60wouNga*N0**<^?+#=mpvjSj#;8(`{pMJrp{dBs zo_94m*<#VEuqd!ML#khBiWYrv&DTv+*?Rbx9rV?gU1+;}l!Ed_KxI8fD%HzHHveR| zp?)RQP@`b$oB$!1&YXzce8C=?P&TOr7|B59fE-!~oBEQqRn-g&hC&P`fcI+nG%z%jJXpe^`E%ehsD;X>(Kb(6&{XuL>1f?rC{Z3?xp*AZq*}BG4zfvzXp+x zv`=hQ3QtXa)Yf&G9J9!aTpR$QJGPS`Tri{IogEB%frra?qH%7E!$gghK?@2PMa5{d z#xF<=%D2aJpobSDJ(#%dwskEXQQG$AD!-1ozPbq(DfrEkH72fLO^Uk6fs#c3C(%rx zO7=kSiZ&5Xzhz`!GVWR4k0Kj{{rTme8zQu1>uL+h3(8t5iVS-J#$Htfwh5^9*Ylc& z`L9AJ_~ijPUY*M(I}M<>G}#%QI`~iSMELSVw7x(CfilYY0GBv3XW>BX1SRk1#H^<) z4y{%vSoe=@yOb*ZV8lOkjPOAm2j5`%DMoB#;kJ>j_F5CeFW%hi%Emu!gZz0GFn4;!t<{nlKt zl-_sjJMQLJ%yMgOQ37oVq*#YA3stEcCCl>@K0&YsusLPEQitA}2FEMNh+!}Zh-Zjo&E^JjO zrJ^=Ni0llv2f~4%bOCqfjn{pi^j4db@39=o-#KiL>lHFw5XoM@0X*~?A*0u>^I8g- z+|ktXDW^+cbotbP4~FfIaFvd~#V{NXoIhzQ$*HUu*l6Ab~4pHEbC*_Kvn=*9K1q>M&{HIj2aaK_M7LM%IDk#ABQoH}ip6xx%lKYOu> zJO($^MPOmb2p{iYpx9vvajRoS!2c~0%fOp%R%A<7TW zdr_Zjei=t7>~-!z{I+HCxV+Fk$wKysGM-uuCGwXch$;@TlItl1{u*^SdIfXx=~mjq z;$A?KDKq}c9GYy?dq!58-KO~K?x9Jn$OLY~=ktQOw;b*SD-}hi)PJ1JX}=!9gDd)xllOOB%YT{cc>hyNEkVrN9rO~YGLi1w1)5_X< z`}JnZ;{J5$|Af8~j8&T%psJ-KN4ZZs!(>eh3rTWC_}n)5I5;?7!mor!S#+m{_cOKedkqLy7ZDR9;2*C zGZ)6jDsj{;2HYku^-Cwb7{t|_v3#Cy2i^Mg0SDX(7Q=4IeJ&jvO^wdq-hDv5%FXoR zqc9Y(Dp|^OqWHXA^z`jyEC~E@c5hIHflt?p2sp`;@%%DhywBwgHWwYGXS_sN^nG@4 zY_w}Xbv8ReL(f2yz^8M(!cw8>pFud&PJr!|77HK~^0DiN`^5P%P67=7B zAevwy^9ZXAjj@=x-dnw{wEvZ~+w{dZmMeoA3HLIPvAZ8d4{ z%*)lK{rOI~G}+Fd+-GbiBA%L`TjF+|C#1_a9`DaD8;%FD=ez9-22*d{k9>ET%{A6L zQg$up+Ep#*{N~+HG@yklv;EVhy@c$}`c&z7lY(ro^VTRLo|yVc{>VU7{xE^_mcXl> zVGh@0b>{X{b~sex5z1IWad~+pA|AV4$hCWrU=Z7 zbMtRlFP031v9BzrLWhkm4pC&i20QKy)f)A~F?YW@Wn^TuTy(wQ^E!~%TTJceM=~?K zy}5V4=s{jc<9B8FH+ACka$nTgm`uQ79w%4C`+QgcsRPsx8-5}S`d&<5NPm(miM(+d zJdJ6#92IB&eB26MYH_68c$#zvHdtbWlKJv}A$EYGl#bc;+IS&F6TF1NGw^0x&~qpG z*8+XI-m|QHc=Q-4RNdVX%u{cGY~~uQY@tjOjg9DUd;6K}(R3@7Xt)`jsY=s?5UiuAvK(fR8Jj~mWgK}B8hY0O zO;&mIrIVHTPe7(>=8zZmbGop`tqYF69zaIbN(`GIVbM5we{JFnxC6}QXKQG(w(Hz8 zFIMzQN_XDq1M=7%p%ak(mzZGTiLiwr@qr?uO&(EhIBy)!{1lB+<`U9B9Bc8mkMd2g z4yG&sRgKh+TSa!uqCME4{Ump6`+GUlP}>aw%&%AC0`%{W)Z7R++?EHG2t{L9 zVZP{$Ual&`X#}KopVTS8cO+BBz*#QlA8^zbRAh^hA${2g>w2-u@DLXQ49moy(b}@r z$HGBkqL{-CONHP^G>X*G`=_vC2>40bmy4PYy*UO-Es}x>9$CQwGo2ZBXlbk@EZb#Dx*iBzzr}* zaazvn=6B1kt8V?#S#M;ynK${Qn7ewXsXzN;npK#u=J1TVcvy$;c{K+Ro$f>^ST&N}bC3^U)zj$mwgaI4MpDG67%0 z0KUGj3C+K&{omdBV1oJ-%Jx(d_+HbGx|5<~w*{`B{F?op!)y$j)bo%c1eFAWG!)WU z{d3=MOT4#`3^x18-dX?Oz~En;J*+yTnG8i4UGI)6R()U2e&+}g{ikW*ll&P?Fix7xC&_t|FLa!xJBzWpBLNb|S7VIT)71td z?CHq=f=UeC0TNfJ8^HrmPy}MK5JwBglgehNKZ-nTMtv}llZLZ}ki!EzJ-H5Y{e(+$ zefdRRmZnN8E2)#^9FNONFo$dXShFwmuI!mxHld}W@O!CKbpw(TDyrHdFes%i2U&dM zhlYk`e|?ZDnkNVjWey@HeyyyCmnH1Th$`na^^|CfmAu0pi2?vm0yE8ir@g@og2_T6 zATCe?2$tFCv}`KaiHG2uE zGPN~;Mm8Z!OEw&JkYjYV%yphcgP>9<+aN_R-4l@*G*V3qPb@ZY7$n*5s-3MIUq+=) z(Pv%wS5y`8(&y!tf+U1WRzc0VfQUXmK;Z`loUhb8{|}eifCk*>+apD1H4cOKV?4g? z5s5VJGqx`0C7eUa#K(_qAZ1Wy=|Xrr&9Wu*-aR?qIEpxap+n~)UCde|2its0clg)n zM#4%i$NX^PP$|n2WdArg6Rvqn#Q0+6X{y>6qG59GhDQFbu{fX5gvyaNuNfD#)v?Kl z&}9p;D(k2WlvdpUoREky#MxvmL|I9Sn5W+!AEUknQni+jBs8;OKvw(xcH~p8xTX}h z45F2AS4rUwnT)$a3HfS;5dFEi+w+y!3cJp9i5S5M-Uwi~HML`&DDKbmt6@tkYbqTT zS%4X}(#IRd>=Cxe>l+yXkfTN3X~NBCmIP+Fs(kdj9}9W7iE8Idg5|_M;HC^S1q)Rq zDmM2`<@wH&0aFO{gE$`ieT4^_OK86_m+xPtl;MkUMpTL9kXm?@?hQ@9nfi zS!LxOUiTyHXE@|v?icH;ZY#D~Zp&8Kh_ETldU9S~0#Il|x9F|9F*e-ekYONsvGTmU zyjuZC%?H4X>F5ysDQ@+xKo3A6;!c|P8=(kI`jz$dFF48gYJ0FKqNe5ESfo~&ZhCsU zW+kUkuk#uTd2#NQURIoK`Lt zdjI+-C#~21{DsoCauONnsToe?)>3iH@OK_xWS!jGj8Q(WNHyj^lX1BnI(m3${{%qj zPch=wP<4>n^)u757S0Dt@NVLPZ-V;))BfPW#_p_q*TmFCYb-}`mj8FoRNp%y-RC)b zHji2Cbx&ssjvTM#YCR`{)~u~^Mmtl{4}Yp~^QY@*g>)wxOH4}@E?#L>!yAV;?u8PX)(#MmL4ikhNBV(##pN4p~p`h@VzzAN0E53 zF6cUwgvN-Z`Mtk6{-_4_`#h{mYnb6csGsTlNxjGW65iuUE?MzcwO$M1H@+NCC%7BP z_s(he8&y*h9wxH?y>*k@-qY%j?`|LugR`_QgMm(sp*RtJIKUQ`t&l4gj7r)xB!8FA zKA?ZB`E1Pt51mh^giiNc!X2+tAazq+l4EwCdGmPo`9se$q%PTE zjcdVqlzPMTcN*L4$*4uz)AP5S?03Nh13#?h)oY&|pM5^xkM<4c)mqxi#R9c5orZwi zjWuNBaGm70=+=jD}Pw-dV(v z`DGrNVk4m+ce4RY$*k`ki`RG?<9DV&t_y#39*PNfA}S_3^mGPRiNcn|&Jdf^Z+z1C z2_Hx)?*C6LP&Oe*P1uuL+VAma)%#3r8Mqw!+Y1S2O2K#j^!*{J^NxFKRDK&lxv}qJ zC~Y}<-YmVfe-Ppm`eXS*3Sxyq3StBkAmrSsSCeILi8gmP`M}&Ts<^xjZ%V-{V7%Mw z^Pe2w40S+CYK~V763gpXiyT*6%(RDj8z~=4zZl+UOH`pt(LPp5&=mW`I0~X`1`+VnkNzJG)7;->a;7fKbbua8BpgtZ`tA93c^ZbGl3I%o{4SQj$q`y z8o+|Uq{OEKkq=o{SJ&`L9W5;_&uI>_9)1Wm=u5ZA8HHG6OnDq+4?}A5?|;u1Yfb(c zSZTGn&_f6#j98CVN%m0fFzL9S`x-z)1Ly4QOxOErFvw`+-%;fn6=|GSnEwj#FtIc8 zy!Px7=iJ;J*q}QHk`f$-2rL|4uZEpZYlpA@swvGZFOMx*K(hjE#ols(7-7v z#bLY)pYy)p{5$OmGgjmt8;eH4wEOL04?-=rD^m3brt|t+pUXeK!s86#3wyoOK2=}% zhWfvKaXg)&t^0W-US7e_dK2pIxHq@4&yo8Eb92z$4{N}itK0h%Uj9+8R)#a)*S$8! z>|BsagWM-~%#((Jig4Hly((eshYZ>v?vfL8Va7nx>b3@*9BDGHCClz(tWx$Uj;2p` zMg|3>QzHlod*JhJM06F@!oDyKwLTl5&Paz?7N5LbAD zaNeOPB8EN+$9Lo%G@_{qp0z$&5f5&kXAOsCtCE|M4dQaFLAIS?rOi;0M+7`QZ(-Uj zhp&DgFO<4YM?8lceoznZ$E5cw_Q)k!?CJHw-08B3-#49e1#)%U@FhH-^TqM5(vM-_;}*uXYwaN@%7frovlR)=;$NQ1=QiCV6;|}4v z_c=k(jNtty86+E+pA%KrTb}FwO9C7QKXZzZ_HRxuHl!Gm%{SvHI-X`D!N8`3W_^#~ zXD$%1+Y@I9h?>LeFHQDJDRq)9UZMxvdH!oIX3m)KaX6Q>u(2rE=bm8TzfYe_OToMM zpz8e|$Et{*zRxaAHfw#qQw?a4KjSXU#Zw`OblsVUAd|?Mnc=VqJ$xIVud`1QCltKm;U26>^2M z+uHb11usQ&Jdf#*kB?hUs@mgJ*)6BZ=fPV25Qg5jV&6T{7mW1jAHkkp?zM(sk10~2 zN!OG4tKCGU{6_N)p9izs!x>$-B?wez3xqgTJ74yGskfZ@n&W*f`+gZJGCe!n7luKZ zChWt1GGDn-E2CZbCm>!(9(&1}KljruEG;deHYWuxU^XEnVs|qTtyr1vasW%I z#%`@m$agKkMHI*+YbHKr+C(*Pm_%`(<3}1UpicqS|2Stobc%rr^Qi zYMi&DjwC28*h<<_`AFfxJB&64d+CU`OJZ}gN#0!K<`u4EV z&_umM+l#3TF4Vbn9(Pnog9Ck- z%pKZ!JqHQ;m}lO(Clu9i?s#tZ)wQBRCkQ=aXlR03T{_~w`rSJ?x=qfglV@>!+*iZbQ+JclC$k!Lw$c+&?r* zG`TD_HczU{%PR=bkHaFQGz&SDiKFbkuaeOALrc@sGLr?6i=|ouUJL{xQWD~d#-O|h z$jJJ3Cfb=J`6NHz3WGFT9@Y7vwt-zTSVL{h67 z2`x={A+diz5#*u_IGHDYc)M+8uBbr|`gBA-Q3qfIvOZ{97Ru_ko2r@Sg?8Rf1_f(nd6c3r(}}ft+yNI zWHmHf5V=T#w~^5M&X{(;h-GP*%l1N1Xe__>)s&wKT>2GUDjGyD6)O;g)a}CNzH#-I zK(?MxH2!pD+sy8A%FE5HBL^?|K7bXJjvRc?y)7>J3p-ZmnpFjxBKTL_)CF7lQ&q?D z$w}*8icZ_>(uMCs``NR%`>LaK$wlYgyiSpy$m3=p!7g)cylR&V3eFC5J z0sGcvIC!H5w@kN&Rk%ggfQ@=^1{O(-JZ_f%4ugu{Ed-BQK`yAF>tG)m%sPpo4~H&? zht5=W5mqacm&Uq9H=B+v_G_`O$X}lM3C`g8`T)q|ModfW$KL6wc~fms>@UB!$KIJc6pjHhq8ygzspG@a!nHBRx%Ul#aZtd$5KqD zGKwhGUH9yeri!2m8sRv^oJ!)t-X}96;+rh7^EG|q(Vr3)JiSMps@8i3r&eOTtPkq* z*DDh5t=Fj<&k4Ej!d94XFKC-1lrhG=0Z)(x%<}SbV68XP$wIZo^)5##7`&fm60`M1 zq$622k>+NmUU=yB=|WYFBWMovBVp83{^l-S0U|>H^S_+_S+wtdBjB=j317@}eHi1h zj@unFhBXWN8b2q4;i9^NH*a)WHmy?l8HYTGiVe<|GvG(knmELjpb3HC$jLolY2th3oZwlFP*cN4a<~8XFVK$_uA{ z_3mb5(l;C&8gSqjaAj&%(`+ouft<0P?uq?X)gR8}lco}RiOWJ!6kabp=N1;~?bi4q z)$!+cI4!WrW=a3$l*qorv3X->*nNGg&fSC+2zEkb!wlyH>;Ubbb!y;uxSgVD@<|HK zd;2`F0aZ7_&^PYl2yS}$16uw@Bm~FD1&AVI>iq@aNOrkXCyUZ+ z&9B@l00@*-;~bw;a4Ss$$f=NLO&QCr>}_|V)2lgb4jsV$gOPab7ukG&?ZF3Gu|5g8 zYd*Bgmg^o5Br$^9GEs97W|Ydao~F3r>jN=egO^y(5Qe5!E!*=SbOA!8rmtK%xXlb%keB9XObju)o4wB_hHu_sS^SWCiVtTbr{TG=uASr-1 z#^bIr)#Iv&0GW(GYpk4M9<0|N$zs%+ffJFXFC>XWd z-X|IV{v6=8=pczc`*^QIJ$BSIm(QilXM-=M!G(gfFQDxlI#R}kOzefukeKJXrhTob zm`3GDlt_#HlLt$R)DcEUv+`G&FIKv~1~T6!`Ee>!k>d^S{hGZ9`&=jRYEpN55p7(q zcQd{b#%N^OOg?i?qy#LdSC)CkMOhgpjVV8OF<|t_}+kbjwj?ko||WasgL)n)%htW=rw`&_sf zq(C3Yu$)zzA&qXsp~JMaighcQF$SAp9E<_P_;(oWz7_sCZNj~;;V;+0CIoWb6 z$}%YC8mb3T+)I`x@JBIC$s7;dkrf1-!3-C%+nG}5)&~)|3nzCsZ;LOj@+PBN+AEfx zlc3{ZB6{%pjL~N~4y6Z)jZ7O!v~G{t*PC9+1whRn#nDBCZ?oH+Elw4?kioAWfX<%R z(xdWQ=_#_E_I~zCT+WNroFuT)idkCO&O=l}FaVe)6cA%%K9fsY=HOz`B5qGZz6;iv z6ii=lo~n%q`D*-@$&vP)p)?F(&_#OK`AgWKR9P+h{YmI=Q~A>xX4t_uk=f612`e?e zp-IYEv<>qMsh=T^o$(1Ip0NnO98H7*D=G+lH^n$@z|!zy8XH{@7KT#s1ASQbz_eGq zE>)W6{iEWbJIM(%a2emmrt>)rr%>r7Pog4fLlMqah2K-RX1M&VLNSVmoQy+%P-oakW^nmzxg2d? z_$NWU7ZVVJVA*)_2d9yTz5&jSi^?>S}&$euo}c7~G@q%cSFY?OUa~c^b!15lNc$E+n)?mwZLZ z3KSP9(bhVGC5yT=hVpGO0M-$N--|%TW9&KFPNCF@=ZEV<<*CRY{-83`=MM}d3)3Sd zG09eHfzhhs${f0};LIGu)QjoRjwhXIPJ-an$wz-^nRh+GO)x2%a%eT#t&K(CFpiq) zWr`B*jM$H*>@!BYmdd6b_axz@D0`TSX?s2(${0r`ePX|aTh#BG^!yZ@uQt(C{qe<1 Wucxe{=M)bLa+3vom#h*u4EP_1yh&I9 diff --git a/docs/content/shared-javascript-and-cpp-documentation/multi-touch-guide.md b/docs/content/shared-javascript-and-cpp-documentation/multi-touch-guide.md new file mode 100644 index 0000000..ba1fc6d --- /dev/null +++ b/docs/content/shared-javascript-and-cpp-documentation/multi-touch-guide.md @@ -0,0 +1,148 @@ +/** + * + +Multi-Touch Events +================== + +Touch events are received via signals. + +For C++ API see Dali::Actor::TouchedSignal() and Dali::Actor::HoveredSignal() for more details. + +For JavaScript use actor.connect( "touched", myCallback ) and actor.connect("hovered", myCallback ); + +### Hit Testing Rules Summary: + + - An actor is only hittable if the actor's touch signal has a connection. + - An actor is only hittable when it is between the camera's near and far planes. + - If an actor is made insensitive, then the actor and its children are not hittable; see Dali::Actor::IsSensitive() + - If an actor's visibility flag is unset, then none of its children are hittable either; see Dali::Actor::IsVisible() + - To be hittable, an actor must have a non-zero size. + - If an actor's world color is fully transparent, then it is not hittable; see GetCurrentWorldColor() + +### Hit Test Algorithm: + + - RenderTasks + - Hit testing is dependent on the camera used, which is specific to each RenderTask. + + - Layers + - For each RenderTask, hit testing starts from the top-most layer and we go through all the + layers until we have a hit or there are none left. + - Before we perform a hit test within a layer, we check if all the layer's parents are visible + and sensitive. + - If they are not, we skip hit testing the actors in that layer altogether. + - If a layer is set to consume all touch, then we do not check any layers behind this layer. + + - Actors + - The final part of hit testing is performed by walking through the actor tree within a layer. + - The following pseudocode shows the algorithm used: + + +~~~ + HIT-TEST-WITHIN-LAYER( ACTOR ) + { + // Only hit-test the actor and its children if it is sensitive and visible + IF ( ACTOR-IS-SENSITIVE && + ACTOR-IS-VISIBLE ) + { + // Depth-first traversal within current layer, visiting parent first + + // Check whether current actor should be hit-tested + IF ( TOUCH-SIGNAL-NOT-EMPTY && + ACTOR-HAS-NON-ZERO-SIZE && + ACTOR-WORLD-COLOR-IS-NOT-TRANSPARENT ) + { + // Hit-test current actor + IF ( ACTOR-HIT ) + { + IF ( ACTOR-IS-OVERLAY || ( DISTANCE-TO-ACTOR < DISTANCE-TO-LAST-HIT-ACTOR ) ) + { + // The current actor is the closest actor that was underneath the touch + LAST-HIT-ACTOR = CURRENT-ACTOR + } + } + } + + // Keep checking children, in case we hit something closer + FOR-EACH CHILD (in order) + { + IF ( CHILD-IS-NOT-A-LAYER ) + { + // Continue traversal for this child's sub-tree + HIT-TEST-WITHIN-LAYER ( CHILD ) + } + // else we skip hit-testing the child's sub-tree altogether + } + } + } +~~~ + - Overlays always take priority (i.e. they're considered closer) regardless of distance. + The overlay children take priority over their parents, and overlay siblings take priority + over their previous siblings (i.e. reverse of rendering order): + +~~~ + 1 + / \ + / \ + 2 5 + / \ \ + / \ \ +3 4 6 + +Hit Priority of above Actor tree (all overlays): 1 - Lowest. 6 - Highest. +~~~ + + - Stencil Actors can be used to influence the result of hits within a layer. + If a Stencil Actor exists on a layer and that Actor is marked visible then a successful + hit can only take place in the area that the stencil Actor marks as visible. + The hit can be in any Stencil Actor in that layer, but must be in the region of one of them. + Stencil Actor inheritance behaves as with rendering in that any child of a Stencil Actor will + also be considered a Stencil Actor. + + Touch Event Delivery: + + - Delivery + - The hit actor's touch signal is emitted first; if it is not consumed by any of the listeners, + the parent's touch signal is emitted, and so on. + - If there are several touch points, then the delivery is only to the first touch point's hit + actor (and its parents). There will be NO touch signal delivery for the hit actors of the + other touch points. + - The local coordinates are from the top-left (0.0f, 0.0f, 0.5f) of the hit actor. + - The following pseudocode shows the delivery mechanism: + +~~~ + EMIT-TOUCH-SIGNAL( ACTOR ) + { + IF ( TOUCH-SIGNAL-NOT-EMPTY ) + { + // Only do the emission if touch signal of actor has connections. + CONSUMED = TOUCHED-SIGNAL( TOUCH-EVENT ) + } + + IF ( NOT-CONSUMED ) + { + // If event is not consumed then deliver it to the parent unless we reach the root actor + IF ( ACTOR-PARENT ) + { + EMIT-TOUCH-SIGNAL( ACTOR-PARENT ) + } + } + } +~~~ + - Leave State + - A "Leave" state is set when the first point exits the bounds of the previous first point's + hit actor (primary hit actor). + - When this happens, the last primary hit actor's touch signal is emitted with a "Leave" state + (only if it requires leave signals); see the actor property leaveRequired. + + + - Interrupted State + - If a system event occurs which interrupts the touch processing, then the last primary hit + actor's touch signals are emitted with an "Interrupted" state. + - If the last primary hit actor, or one of its parents, is no longer touchable, then its + touch signals are also emitted with an "Interrupted" state. + - If the consumed actor on touch-down is not the same as the consumed actor on touch-up, then + touch signals are also emitted from the touch-down actor with an "Interrupted" state. + +@class MultiTouch +* +*/ diff --git a/plugins/dali-script-v8/.gitignore b/plugins/dali-script-v8/.gitignore new file mode 100644 index 0000000..9884cf9 --- /dev/null +++ b/plugins/dali-script-v8/.gitignore @@ -0,0 +1 @@ +docs/generated diff --git a/plugins/dali-script-v8/docs/.gitignore b/plugins/dali-script-v8/docs/.gitignore new file mode 100644 index 0000000..8f030d1 --- /dev/null +++ b/plugins/dali-script-v8/docs/.gitignore @@ -0,0 +1,6 @@ +/generated/* + + + + + diff --git a/plugins/dali-script-v8/docs/README.txt b/plugins/dali-script-v8/docs/README.txt new file mode 100644 index 0000000..c2322b3 --- /dev/null +++ b/plugins/dali-script-v8/docs/README.txt @@ -0,0 +1,11 @@ +// Follow instructions on the internets on how to install yuidoc +// Then run this command + +yuidoc --config yuidoc.json -e ".cpp,.js,.md" -o generated .. ../../../docs/content/shared-javascript-and-cpp-documentation/ + +// -e says what extensions to pass, we have comments in js and cpp files +// -o specifies output directory ( in this case we output to a folder called generated) +// The list of directories after the generated, is the folders to scan for documentation + +To view the output +firefox generated/index.html & diff --git a/plugins/dali-script-v8/docs/content/actor.js b/plugins/dali-script-v8/docs/content/actor.js new file mode 100644 index 0000000..ce095cd --- /dev/null +++ b/plugins/dali-script-v8/docs/content/actor.js @@ -0,0 +1,647 @@ +/** + * + ## Actor API + + Actor is the primary object with which Dali applications interact. UI controls can be built by combining multiple actors. + + There are different types of Actors supported by Dali. They all have the same + base functionality of the actor class. + +``` +var actor = new dali.Actor(); +var imageActor = new dali.ImageActor(); +var textActor = new dali.TextActor("hello world"); +var meshActor = new dali.MeshActor(); +var camera = new dali.CameraActor(); +var layer = new dali.Layer(); +``` + +### Hello world example +``` +var myActor = new dali.TextActor("hello-world"); + +myActor.name = "my first actor"; +myActor.color = [ 1, 0, 0, 1]; // Red,Green,Blue, Alpha ( 1 == max, 0 = none ) +myActor.scale = [ 2, 2, 1]; // double the width and height + +// by default an actor is anchored to the top-left of it's parent actor +// change it to the middle + +myActor.parentOrigin = [0.5,0.5,0.5]; + +// add to the stage +dali.stage.add( myActor ); +``` + + +### Positioning Actors + +An actor inherits its parent's position. The relative position between the actor & parent is determined by 3 properties: + +1) ParentOrigin. This Vector3 property defines a point within the parent actor's area. + + + +The default is "top-left", which can be visualized in 2D as (0, 0), but is actually Vector3(0, 0, 0.5) in the 3D DALi world. The actor's position is relative to this point. +``` +// to change parent origin to the centre +myActor.parentOrigin = [0.5, 0.5, 0.5]; +``` + +2) AnchorPoint. This Vector3 property defines a point within the child actor's area. + + + +The default is "center", which can be visualized in 2D as (0.5, 0.5), but is actually Vector3(0.5, 0.5, 0.5) in the 3D DALi world. The actor's position is also relative to this point. +``` +// setting anchor point to the centre +myActor.anchorPoint = [0.5, 0.5, 0.5]; +``` + +3) Position. This is the position vector between the parent-origin and anchor-point. + + + +Therefore by default, an actors position is the distance between its center and the top-left corner of its parent. + +An actor added directly to the stage with position (X = stageWidth*0.5, Y = stageHeight*0.5), would appear in the center of the screen. Likewise an actor with position (X = actorWidth*0.5, Y = actorWidth*0.5), would appear at the top-left of the screen. + +Note that since DALi is a 3D toolkit, this behaviour is the result of a default perspective camera setup. + +### Actor callback events + +The actor provides the following call back events + +| Name | Description | Parameters passed to call back | +|-------------------|----------------------------------------|--------------------------| +|touched | touch event | (actor, touchEvent ) | +|hovered | mouse or pointer hovering over actor | (actor, hoverEvent) | +|mouse-wheel-event | mouse wheel events | (actor, wheelEvent) | +|on-stage | actor has been moved on stage | (actor) | +|off-stage | actor has been moved off stage | (actor) | + + +#### Touch event + +Used to detect multiple touch events on the actor. The state of each touch point can be: ++ "down" = touch down ++ "up" = Touch up ++ "motion" = Finger dragged or hovered ++ "leave" = Leave the boundary of an actor ++ "stationary" = No change from last event. Useful when a multi-point event occurs where +all points are sent but indicates that this particular point has not changed since the last time ++ "interrupted" = A system event has occurred which has interrupted the touch or hover event sequence + + + +``` +touchEvent = { + + pointCount: int, // number of points touched ( multi-touch ) + time: int, // The time in milliseconds that the touch event occurred. + points = [ touchPoints ], // array of TouchPoints, to support + + TouchPoint = { + + "deviceId" : int, // Each touch point has a unique device ID + "state" : string, // touch state ="down,up,motion,leave,stationary, interrupted } + "sourceActor" : actor, // the actor that is emitting the callback (the actor that is hit maybe a child of it) + "hitActor" : actor, // actor that was hit + "local" : {x,y}, // co-ordinates of top left of hit actor (local.x, local.y) + "screen" : {x,y} // co-ordinates of top left of hit actor (screen.x, screen.y) + } +} + +function OnPressed( actor, touchEvent ) +{ + var firstPoint = touchEvent.points[0]; + log("first touch point = " + firstPoint.screen.x + "," +firstPoint.screen.x + "actor= "+firstPoint.hitActor ); + + var anim = new dali.Animation( 4 ); + var rotation = new dali.Rotation( 90, 0, 0 ); // pitch, yaw, roll + anim.animateBy( actor, "rotation", rotation ); + anim.play(); + return true; +} + +// connect to touch events +myActor.connect( "touched", onPressed ); + +``` + +#### Hover event + +``` +hoverEvent = { + + pointCount // number of points hovered over + time // The time in milliseconds that the hover event occurred. + points[] // array of TouchPoints + + TouchPoint = { + // See touchEvent TouchPoint object + } +} +``` + // connect to touch events + myActor.connect( "hovered", onHover); + +#### Mouse wheel event + +``` +mouseWheelEvent = { + + direction, // "vertical" or "horizontal" direction the wheel is being rolled + shiftPressed, // boolean, shift key is held + ctrlPressed, // boolean, ctrl key is held + altPressed, // boolean, alt key is held + keyModifiers, // bitmask of keys pressed + point {x,y}, // The co-ordinates of the mouse cursor relative to the top-left of the screen when the wheel is being rolled. + rolled, // offset of mouse wheel rolling, positive = rolling down, negative = rolling up + timestamp // The time in milliseconds that the mouse event occurred +} + +// connect to touch events +myActor.connect( "mouse-wheel-event", onMouseWheel ); +``` +#### Key events + +Key events are performed using the dali.stage object and dali.keyboardFocusManager. + - {{#crossLink "stage"}}Stage{{/crossLink}} + + +#### Multi-touch events + +See + - {{#crossLink "MultiTouch"}}Multi Touch Events.{{/crossLink}} + + +### Actor Properties + + Name | Type | Writable | Animatable +------------------------|------------|--------------|----------- + anchorPoint |VECTOR3 | ✔ | ✘ + anchorPointX |FLOAT | ✔ | ✘ + anchorPointY |FLOAT | ✔ | ✘ + anchorPointZ |FLOAT | ✔ | ✘ + size |VECTOR3 | ✔ | ✔ + sizeWidth |FLOAT | ✔ | ✔ + sizeHeight |FLOAT | ✔ | ✔ + sizeDepth |FLOAT | ✔ | ✔ + position |VECTOR3 | ✔ | ✔ + positionX |FLOAT | ✔ | ✔ + positionY |FLOAT | ✔ | ✔ + positionZ |FLOAT | ✔ | ✔ + worldPosition |VECTOR3 | ✘ | ✘ + worldPositionX |FLOAT | ✘ | ✘ + worldPositionY |FLOAT | ✘ | ✘ + worldPositionZ |FLOAT | ✘ | ✘ + rotation |ROTATION | ✔ | ✔ + worldRotation |ROTATION | ✘ | ✘ + scale |VECTOR3 | ✔ | ✔ + scaleX |FLOAT | ✔ | ✔ + scaleY |FLOAT | ✔ | ✔ + scaleZ |FLOAT | ✔ | ✔ + worldScale |VECTOR3 | ✘ | ✘ + visible |BOOLEAN | ✔ | ✔ + color |VECTOR4 | ✔ | ✔ + colorRed |FLOAT | ✔ | ✔ + colorGreen |FLOAT | ✔ | ✔ + colorBlue |FLOAT | ✔ | ✔ + colorAlpha |FLOAT | ✔ | ✔ + worldColor |VECTOR4 | ✘ | ✘ + worldMatrix |MATRIX | ✘ | ✘ + name |STRING | ✔ | ✘ + sensitive |BOOLEAN | ✔ | ✘ + leaveRequired |BOOLEAN | ✔ | ✘ + inheritRotation |BOOLEAN | ✔ | ✘ + inheritScale |BOOLEAN | ✔ | ✘ + colorMode |NUMBER | ✔ | ✘ + positionInheritance |NUMBER | ✔ | ✘ + drawMode |NUMBER | ✔ | ✘ + sizeMode |NUMBER | ✔ | ✘ + sizeModeFactor |VECTOR3 | ✔ | ✘ + + + + + * @class Actor + */ + + +/** + * Actors parent origin + * + * @property parentOrigin + * @type dali Vector3 + * @default TOP_LEFT (0.0, 0.0, 0.5). + */ +parentOrigin + +/** + * Actors parent origin X + * + * @property parentOriginX + * @readOnly + * @type Number + */ +parent - origin - x + +/** + * Actors parent origin-y + * @property parentOriginY + * @readOnly + * @type Number + */ +parent - origin - y + +/** + * Actors parent origin-z + * @property parentOriginZ + * @readOnly + * @type Number + */ +parent - origin - z + +/** + * Actors anchor point + * @property anchorPoint + * @type dali Vector3 + * @default CENTER (0.5, 0.5, 0.5) + */ +ANCHOR_POINT; + +/** + * Actors anchor point x + * @property anchorPointX + * @type Number + */ +ANCHOR_POINT_X + +/** + * Actors anchor point y + * @property anchorPointY + * @type Number + */ +ANCHOR_POINT_Y + +/** + * Actors anchor point z + * @property anchorPointZ + * @type Number + */ +ANCHOR_POINT_Z + +/** + * Actors size + * @property size + * @type dali Vector3 + */ +SIZE + + +/** + * Actors width + * @property sizeWidth + * @type Number + */ +SIZE_WIDTH + +/** + * Actors height + * @property sizeHeight + * @type Number + */ +SIZE_HEIGHT + +/** + * Actors depth + * @property sizeDepth + * @type Number + */ +SIZE_DEPTH + + +/** + * Actors position + * @property position + * @type dali Vector3 + */ +POSITION + +/** + * Actors x position + * @property positionX + * @type Number + */ +POSITION_X + +/** + * Actors y position + * @property positionY + * @type Number + */ +POSITION_Y + +/** + * Actors z position + * @property positionZ + * @type Number + */ +POSITION_Z + + +/** + * Actors world position + * @property position + * @type dali Vector3 ( read-only, not animatable ) + */ +WORLD_POSITION + +/** + * Actors world x position + * @property worldPositionX + * @type Number ( read-only ) + */ +WORLD_POSITION_X + +/** + * Actors world y position + * @property worldPositionY + * @type Number ( read-only ) + */ +WORLD_POSITION_Y + +/** + * Actors world z position + * @property worldPositionZ + * @type Number ( read-only ) + */ +WORLD_POSITION_Z + + +/** + * Actors rotation + * @property rotation + * @type dali Rotation object + */ +ROTATION + + +/** + * Actors world-rotation + * @property worldRotation + * @type dali Rotation object ( read only) + */ +WORLD_ROTATION + +/** + * Actors scale + * @property scale + * @type dali Vector3 + */ +SCALE + +/** + * Actors x scale + * @property scaleX + * @type Number + */ +SCALE_X + +/** + * Actors y scale + * @property scaleY + * @type Number + */ +SCALE_Y + +/** + * Actors z scale + * @property scaleZ + * @type Number + */ +SCALE_Z + +/** + * Actors world scale + * @property worldScale + * @type dali Vector3 ( read only ) + */ +WORLD_SCALE + +/** + * Actors visible flag + * If an actor is not visible, then the actor and its children will not be rendered. + * This is regardless of the individual visibility values of the children i.e. an actor will only be + * rendered if all of its parents have visibility set to true. + * + * @property visible + * @type Boolean + */ +VISIBLE + +/** + * Actors color. + * The final color of the actor depends on its color mode. + * 4 components, red, green, blue and alpha. Each range from 0..1 + * @property color + * @type dali Vector 4 + */ +COLOR + +/** + * Actors red color + * @property colorRed + * @type Number ( 0..1) + */ +COLOR_RED + +/** + * Actors green color + * @property colorGreen + * @type Number ( 0..1) + */ +COLOR_GREEN + +/** + * Actors blue color + * @property colorBlue + * @type Number ( 0..1) + */ +COLOR_BLUE + +/** + * Actors world color. + * 4 components, red, green, blue and alpha. Each range from 0..1 + * @property worldColor + * @type dali Vector 4 ( read only) + */ +WORLD_COLOR + +/** + * Actors name + * @property name + * @type String + */ + +/** + * Actors sensitive flag + * brief Sets whether an actor should emit touch event signals; @see SignalTouched(). + * + * An actor is sensitive by default, which means that as soon as an application connects to the SignalTouched(), + * the touch event signal will be emitted. + * + * If the application wishes to temporarily disable the touch event signal emission, then they can do so by calling + * + * actor.sensitve = false; + * + * Then, to re-enable the touch event signal emission, the application should call: + * + * actor.sensitive = true; + * + * @property sensitive + * @type Boolean + * @default true ( is sensistive ) + */ +SENSITIVE + +/** + * Controls whether the actor should receive a notification when touch motion events leave + * the boundary of the actor. + * + * Note: Need to connect to the SignalTouch to actually receive this event. + * Should be set to true if a Leave event is required + * @type Boolean + * @property leaveRequired + * @default false, this is set to false as most actors do not require this. + */ +LEAVE_REQUIRED + +/** + * Set whether a child actor inherits it's parent's orientation. + * @type Boolean + * @property inheritRotation + * @default true + */ +INHERIT_ROTATION, + + +/** + * Set whether a child actor inherits it's parent's scale. + * @type Boolean + * @property inheritScale + * @default true + */ +INHERIT_SCALE, + + +/** + * Set how the actor and its children should be drawn. + * + * Not all actors are renderable, but DrawMode can be inherited from any actor. + * By default a renderable actor will be drawn as a 3D object. It will be depth-tested against + * other objects in the world i.e. it may be obscured if other objects are in front. + * + * If OVERLAY is used, the actor and its children will be drawn as a 2D overlay. + * Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer. + * For overlay actors, the drawing order is determined by the hierachy (depth-first search order), + * and depth-testing will not be used. + * + * If STENCIL is used, the actor and its children will be used to stencil-test other actors + * within the Layer. Stencil actors are therefore drawn into the stencil buffer before any other + * actors within the Layer. + * + * @example + * + * var actor.drawMode = dali.DRAW_MODE_NORMAL; // binary 00. The default draw-mode + * var actor.drawMode = dali.DRAW_MODE_OVERLAY; // binary 01. Draw the actor and its children as an overlay + * var actor.drawMode = dali.DRAW_MODE_STENCIL ;// binary 11. Draw the actor and its children into the stencil buffer + * + * + * @type Number + * @property drawMode + * @default 0 (Normal ) + */ +DRAW_MODE, + + +/** + * Sets the actor's color mode. + * + * This specifies whether the Actor uses its own color, or inherits + * its parent color. The default is USE_OWN_MULTIPLY_PARENT_ALPHA. + * + * @example + * actor.colorMode = dali.COLOR_MODE_USE_OWN_COLOR; // Actor will use its own color + * actor.colorMode = dali.COLOR_MODE_USE_PARENT_COLOR; // Actor will use its parent color + * actor.colorMode = dali. COLOR_MODE_USE_OWN_MULTIPLY_PARENT_COLOR; // Actor will blend its color with its parents color. + * actor.colorMode = dali.COLOR_MODE_USE_OWN_MULTIPLY_PARENT_ALPHA ; // Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default. + * + * + * @type Number + * @property colorMode + * @default 2 (USE_OWN_MULTIPLY_PARENT_ALPHA ) + */ +COLOR_MODE + +/** + * Set the actors position inheritance mode. + * + * @example + * actor.positionInheritance = dali.POSITION_INHERITANCE_INHERIT_PARENT_POSITION; // Actor will inherit its parent position. This is the default + * actor.positionInheritance = dali.POSITION_INHERITANCE_USE_PARENT_POSITION; // Actor will copy its parent position. This is useful if many actors are stacked together in the same place. This option ignores parent origin and anchor point. + * actor.positionInheritance = dali.POSITION_INHERITANCE_USE_PARENT_POSITION_PLUS_LOCAL_POSITION; // Actor will copy its parent position and add local position. This is useful if many actors are stacked together in the same place with an offset. This option ignores parent origin and anchor point. + * actor.positionInheritance = dali.POSITION_INHERITANCE_DONT_INHERIT_POSITION; // Actor will not inherit position. Local position is treated as world position. This is useful if a constraint is used to override local position or if an actor is positioned globally. This option ignores parent origin, anchor point and local position. + * + * Switching this off means that using SetPosition() sets the actor's world position. + * @type Number + * @property positionInheritance + * @default 0 (INHERIT_PARENT_POSITION ) + */ +POSTITION_INHERITANCE + + +/** + * Defines how a child actor's size is affected by its parent's size. + * + * The default is to ignore the parent's size and use the size property of this actor. + * + * If USE_OWN_SIZE is used, this option is bypassed and the actor's size + * property is used. + * + * If SIZE_EQUAL_TO_PARENT is used, this actor's size will be equal to that + * of its parent. The actor's size property is ignored. + * + * If SIZE_RELATIVE_TO_PARENT is used, this actor's size will be based on + * its parent's size by multiplying the parent size by + * SizeModeFactor. + * + * If SIZE_FIXED_OFFSET_FROM_PARENT is used, this actor's size will be based on + * its parent's size plus SizeModeFactor. + * + * + * @example + * actor.sizeMode = dali.USE_OWN_SIZE; + * actor.sizeMode = dali.SIZE_EQUAL_TO_PARENT; + * actor.sizeMode = dali.SIZE_RELATIVE_TO_PARENT; + * actor.sizeMode = dali.SIZE_FIXED_OFFSET_FROM_PARENT + * + * @type Number + * @property sizeMode + * @default 0 (dali.SIZE_MODE_USE_OWN_SIZE; ) + */ + SIZE_MODE + +/** + * + * @brief Sets the relative to parent size factor of the actor. + * + * This factor is only used when SizeMode is set to either: + * SIZE_RELATIVE_TO_PARENT or SIZE_FIXED_OFFSET_FROM_PARENT. + * This actor's size is set to the actor's parent size multipled by or added to this factor, + * depending on SideMode (See SetSizeMode). + * @type Vector3 + * @property sizeModeFactor + */ +SIZE_MODE_FACTOR \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/animation.js b/plugins/dali-script-v8/docs/content/animation.js new file mode 100644 index 0000000..ec587fe --- /dev/null +++ b/plugins/dali-script-v8/docs/content/animation.js @@ -0,0 +1,257 @@ +/** + * +## Animation API + + DALi Animation can be used to animate the properties of any number of objects, typically Actors. + +The API supports functionality such as: + + - {{#crossLink "animation/play:method"}}{{/crossLink}} + - {{#crossLink "animation/pause:method"}}{{/crossLink}} + - {{#crossLink "animation/stop:method"}}{{/crossLink}} + - {{#crossLink "animation/setLooping:method"}}{{/crossLink}}, set whether the animation should loop + - {{#crossLink "animation/setSpeedFactor:method"}}{{/crossLink}}, speeds / slows down an animation + - {{#crossLink "animation/setPlayRange:method"}}{{/crossLink}}, only play part of the animation between a set range + - Key frame support. See {{#crossLink "animation/animateBetween:method"}}{{/crossLink}} + - Path Animations. See {{#crossLink "path"}}Path {{/crossLink}} + - Signals to be informed when an animation has finished. + - animate multiple properties, owned by multiple objects with a single animation object + +### Simple example of moving an actor to a set position + +``` +var myActor = new dali.TextActor( "hello world" ); + +myActor.parentOrigin = dali.CENTER; +dali.stage.add( myActor ); + +var anim = new dali.Animation( 2 ); // 2 seconds + +// we're animation the property position of the actor. +anim.animateTo( myActor, "position", [100, 100, 0] ); + +function finished( animation ) +{ + log("Animation finished \n"); +} + +anim.connect("finished", finished ); + +anim.play(); +``` + +### Multiple actor example + +``` +// Following demonstrates: +// - aimating multiple properties on an object (actor properties in this example) +// - animating multiple objects at the same time (2 actors in the example) +// - using the optional, animation options object to set a delay time and alpha function (easing) + +// Sets the original position to be rotated and pushed into the distance + +var myActor1 = new dali.TextActor( "Hello" ); +var myActor2 = new dali.TextActor( "from DALi" ); + +// centre both actors to the middle of the screen +myActor1.parentOrigin = dali.CENTER; +myActor2.parentOrigin = dali.CENTER; +myActor1.scale=[2,2,1]; // scale up x and y by 2 +myActor2.scale=[2,2,1]; // scale up x and y by 2 + + +// reposition them to the left / right, and push them away from the camera +myActor1.position=[-100,0,-2000]; // x = -100, y = 0 , z = -2000 +myActor2.position=[ 100,0,-2000]; // x = 100, y = 0 , z = -2000 + +// start with actor rotated by 180 about x & y axis, so they can twist into place +function createAnimation() { + + var startRotation = new dali.Rotation(180, -180, 0); + myActor1.rotation = startRotation; + myActor2.rotation = startRotation; + + dali.stage.add( myActor1 ); + dali.stage.add( myActor2 ); + + + var anim = new dali.Animation(1); // default duration is increased if length of all animations is greater than it. + + var animOptions = { + alpha: "linear", + delay: 0.5, // used to delay the start of the animation + duration: 3, // duration of the animation + }; + + // move myActor1 z position back to 0 + anim.animateTo(myActor1, "positionZ", 0, animOptions); + + // rotate back to correct orientation + var endRotation = new dali.Rotation(0,0,0); + + animOptions.alpha = "easeInOutSine"; + anim.animateTo(myActor1, "rotation", endRotation, animOptions); + + // Delay the myActor2 by a second + animOptions.delay = 0.0; + animOptions.alpha = "linear"; + anim.animateTo(myActor2, "positionZ", 0, animOptions); + + // rotate back to correct orientation + animOptions.alpha = "easeInOutSine"; + anim.animateTo(myActor2, "rotation", endRotation, animOptions); + + return anim; +} + + +var anim = createAnimation(); + +anim.play(); + +``` + +### GL-ES shader animation example + +The example below does the following with a single animation object: + + - rotates the image actor + - magnifies and color shifts the image using a fragment shader + + + + +``` +// create an image actor in the centre of the stage +createImageActor = function() { + + var image = new dali.ResourceImage({ url:getImageDirectory()+"gallery-medium-50.jpg"}); + var imageActor = new dali.ImageActor( image ); + imageActor.parentOrigin = dali.CENTER; + dali.stage.add( imageActor ); + + return imageActor; +} + +// Creates a simple fragment shader that has 2 uniforms. +// uColorShift which can add a color to pixel +// uScale which can simulate zooming into the texture + +createColorShiftAndZoomEffect = function() { + + var fragShader = + " uniform lowp vec4 uColorShift; \ + uniform lowp vec2 uScale; \ + \ + void main() \ + { \ + gl_FragColor = texture2D( sTexture, vTexCoord * uScale ) * uColor + uColorShift; \ + }" + + // Shader API + // geometryType = "image", "text", "mesh", "textured-mesh" + // fragmentPrefex ="" // prefix ( optional) + // fragmentShader = "" // fragment shader ( optional) + // geometryHints = [ "gridX", "gridY", "grid","depthBuffer","blending" ] ( optional) + // + var shaderOptions = { + geometryType: "image", + fragmentShader: fragShader, + geometryHints: ["blending"] + }; + + // create a new shader effect + var shader = new dali.ShaderEffect(shaderOptions); + + // add the color shift uniform so we can animate it + // default the color shift to zero, so it has no effect + shader.setUniform("uColorShift", [0, 0, 0, 0]); + + // add the zoom uniform so we can animate it + // default to 1,1 so no zoom is applied + var scale = new dali.Vector2([1, 1]); + shader.setUniform("uScale", scale); + + return shader; +} + +createShaderAnimation = function( shader, color, zoom, duration, delay ) +{ + var shaderAnim = new dali.Animation(duration+delay); + + var animOptions = { + alpha: "doubleEaseInOutSine60", + delay: delay, + duration: duration, + }; + + // animate the color uniform + shaderAnim.animateTo( shader, "uColorShift", color, animOptions); + + // zoom in and out of the image while applying the color shift + shaderAnim.animateTo( shader, "uScale", zoom, animOptions); + + return shaderAnim; +} + +var imageActor = createImageActor(); +var shaderEffect = createColorShiftAndZoomEffect(); + +// assign the shader effect to the actor ( it can be assigned to multiple actors). +imageActor.setShaderEffect( shaderEffect ); + +// create the shader animation +var zoom = [0.5,0.5]; // zoom into the image by 2 +var color = dali.COLOR_BLUE; // color shift the image to blue +var duration = 5; // 5 seconds +var delay = 5; // wait 1 second before starting +var shaderAnim = createShaderAnimation( shaderEffect, color,zoom, duration, delay); + +// also rotate the imageActor 90 degrees at the same time. +var rotation = new dali.Rotation(90,0,0,1); +shaderAnim.animateTo(imageActor, "rotation", rotation, { alpha:"linear", duration:duration, delay:delay }); + + +shaderAnim.play(); + +``` + + +### Animation alpha functions + +| Name | Description | +|--------------------|--------------| +|default |Linear | +|linear |Linear | +|square |Square (x^2) | +|reverse |Reverse linear | +|easeIn |Speeds up and comes to a sudden stop | +|easeOut |Sudden start and slows to a gradual stop| +|easeInOut |Speeds up and slows to a gradual stop| +|easeInSine |Speeds up and comes to a sudden stop| +|easeOutSine |Sudden start and slows to a gradual stop| +|easeInOutSine |Speeds up and slows to a gradual stop | +|easeInSine33 |Speeds up and comes to a sudden stop | +|easeOutSine33 |Sudden start and slows to a gradual stop | +|easeInOutSine33 |Speeds up and slows to a gradual stop | +|easeInOutSine50 |Speeds up and slows to a gradual stop | +|easeInOutSine60 |Speeds up and slows to a gradual stop | +|easeInOutSine70 |Speeds up and slows to a gradual stop | +|easeInOutSine80 |Speeds up and slows to a gradual stop | +|easeInOutSine90 |Speeds up and slows to a gradual stop | +|doubleEaseInOutSine6|Speeds up and slows to a gradual stop, then speeds up again and slows to a gradual stop | +|easeOutQuint50 |Sudden start and slows to a gradual stop | +|easeOutQuint80 |Sudden start and slows to a gradual stop | +|bounce |Sudden start, loses momentum and ** Returns to start position ** | +|bounceBack |Sudden start, loses momentum and returns to exceed start position ** Returns to start position ** | +|easeInBack |Slow start, exceed start position and quickly reach destination | +|easeOutBack |Sudden start, exceed end position and return to a gradual stop| +|easeInOutBack |Slow start, exceed start position, fast middle, exceed end position and return to a gradual stop| +|sin |full 360 revolution ** Returns to start position ** | +|sin2x |full 720 revolution ** Returns to start position ** | + + + + @class Animation + +*/ diff --git a/plugins/dali-script-v8/docs/content/camera-actor.js b/plugins/dali-script-v8/docs/content/camera-actor.js new file mode 100644 index 0000000..818bc85 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/camera-actor.js @@ -0,0 +1,51 @@ +/** + ## Camera Actor API ( extends Actor API) + + +Allows the developer to use actor semantics to control a camera. + +There are two types of camera actor, FREE_LOOK and LOOK_AT_TARGET. By default +the camera actor will be FREE_LOOK. + +A FREE_LOOK camera uses actor's rotation to control where the camera is looking. +If no additional rotations are specified, the camera looks in the negative Z direction. + +For LOOK_AT_TARGET the actor's rotation is ignored, instead the camera looks at TARGET_POSITION +in world coordinates. +``` +// get the camera currently used +var defaultCamera = dali.stage.getRenderTaskList().getTask(0).getCameraActor(); + +var fov = defaultCamera.fieldOfView; + +// increase field of view by 10% +defaultCamera.fieldOfView = fov * 1.1; + +// shift the camera to the left, the rendered scene will shift to the right +defaultCamera.x -= 10; +``` + +### Camera Actor Specific Properties + +| Name | Type | Writable | Animatable| +|------------------------|------------|--------------|-----------| +| type | dali.CAMERA_FREE_LOOK or dali.CAMERA_LOOK_AT_TARGET | ✔ | ✘ | +| projectionMode | dali.CAMERA_ORTHOGRAPHIC_PROJECTION or dali.CAMERA_PERSPECTIVE_PROJECTION | ✔| ✘ | +| fieldOfView | FLOAT | ✔ | ✘ | +| aspectRatio | FLOAT | ✔ | ✘ | +| nearPlaneDistance | FLOAT | ✔ | ✘ | +| farPlaneDistance | FLOAT | ✔ | ✘ | +| leftPlaneDistance | FLOAT | ✔ | ✘ | +| rightPlaneDistance | FLOAT | ✔ | ✘ | +| topPlaneDistance | FLOAT | ✔ | ✘ | +| bottomPlaneDistance | FLOAT | ✔ | ✘ | +| targetPosition | VECTOR3 | ✔ | ✘ | +| projectionMatrix | MATRIX | ✔ | ✘ | +| viewMatrix | MATRIX | ✔ | ✘ | +| invertYAxis | BOOLEAN | ✔ | ✘ | + + + + @class CameraActor + @extends Actor + */ diff --git a/plugins/dali-script-v8/docs/content/constants.js b/plugins/dali-script-v8/docs/content/constants.js new file mode 100644 index 0000000..a6b2e1e --- /dev/null +++ b/plugins/dali-script-v8/docs/content/constants.js @@ -0,0 +1,173 @@ +/** + * +

Dali Constants

+ +Constants accessible under the dali global object. + + actor.parentOrigin = dali.BACK_TOP_LEFT; + actor.color = dali.COLOR_RED; + actor.setBlendFunc( dali.BLEND_FACTOR_ONE_MINUS_SRC_COLOR, dali.BLEND_FACTOR_SRC_ALPHA_SATURATE ); + + +| Constant Name | value | +|---------------|-------| +| ** actor.parentOrigin and actor.anchorPoint ** | | +|BACK_TOP_LEFT | (0.0f, 0.0f, 0.0f) | +|BACK_TOP_CENTER | (0.5f, 0.0f, 0.0f) | +|BACK_TOP_RIGHT | (1.0f, 0.0f, 0.0f) | +|BACK_CENTER_LEFT | (0.0f, 0.5f, 0.0f) | +|BACK_CENTER | (0.5f, 0.5f, 0.0f) | +|BACK_CENTER_RIGHT | (1.0f, 0.5f, 0.0f) | +|BACK_BOTTOM_LEFT | (0.0f, 1.0f, 0.0f) | +|BACK_BOTTOM_CENTER | (0.5f, 1.0f, 0.0f) | +|BACK_BOTTOM_RIGHT | (1.0f, 1.0f, 0.0f) | +|TOP_LEFT | (0.0f, 0.0f, 0.5f) | +|TOP_CENTER | (0.5f, 0.0f, 0.5f) | +|TOP_RIGHT | (1.0f, 0.0f, 0.5f) | +|CENTER_LEFT | (0.0f, 0.5f, 0.5f) | +|CENTER | (0.5f, 0.5f, 0.5f) | +|CENTER_RIGHT | (1.0f, 0.5f, 0.5f) | +|BOTTOM_LEFT | (0.0f, 1.0f, 0.5f) | +|BOTTOM_CENTER | (0.5f, 1.0f, 0.5f) | +|BOTTOM_RIGHT | (1.0f, 1.0f, 0.5f) | + +|FRONT_TOP_LEFT | (0.0f, 0.0f, 1.0f) | +|FRONT_TOP_CENTER | (0.5f, 0.0f, 1.0f) | +|FRONT_TOP_RIGHT | (1.0f, 0.0f, 1.0f) | +|FRONT_CENTER_LEFT | (0.0f, 0.5f, 1.0f) | +|FRONT_CENTER | (0.5f, 0.5f, 1.0f) | +|FRONT_CENTER_RIGHT | (1.0f, 0.5f, 1.0f) | +|FRONT_BOTTOM_LEFT | (0.0f, 1.0f, 1.0f) | +|FRONT_BOTTOM_CENTER | (0.5f, 1.0f, 1.0f) | +|FRONT_BOTTOM_RIGHT | (1.0f, 1.0f, 1.0f) | + + +|** Vector3 ** | | +|VECTOR3_ONE | (1.0f, 1.0f, 1.0f) | +|VECTOR3_XAXIS | (1.0f, 0.0f, 0.0f) | +|VECTOR3_YAXIS | (0.0f, 1.0f, 0.0f) | +|VECTOR3_ZAXIS | (0.0f, 0.0f, 1.0f) | +|VECTOR3_NEGATIVE_XAXIS | (-1.0f, 0.0f, 0.0f) | +|VECTOR3_NEGATIVE_YAXIS | (0.0f, -1.0f, 0.0f) | +|VECTOR3_NEGATIVE_ZAXIS | (0.0f, 0.0f, -1.0f) | +|VECTOR3_ZERO | (0.0f, 0.0f, 0.0f) | + +|** Colors **| -| +|COLOR_BLACK | ( 0.0f, 0.0f, 0.0f, 1.0f ) | +|COLOR_WHITE | ( 1.0f, 1.0f, 1.0f, 1.0f ) | +|COLOR_RED | ( 1.0f, 0.0f, 0.0f, 1.0f ) | +|COLOR_GREEN | ( 0.0f, 1.0f, 0.0f, 1.0f ) | +|COLOR_BLUE | ( 0.0f, 0.0f, 1.0f, 1.0f ) | +|COLOR_YELLOW | ( 1.0f, 1.0f, 0.0f, 1.0f ) | +|COLOR_MAGENTA | ( 1.0f, 0.0f, 1.0f, 1.0f ) | +|COLOR_CYAN | ( 0.0f, 1.0f, 1.0f, 1.0f ) | +|COLOR_TRANSPARENT | ( 0.0f, 0.0f, 0.0f, 0.0f ) | + +| ** actor.colorMode constants ** | -| +| COLOR_MODE_USE_OWN_COLOR, | integer value | +| COLOR_MODE_USE_PARENT_COLOR, | integer value | +| COLOR_MODE_USE_OWN_MULTIPLY_PARENT_COLOR, | integer value | +| COLOR_MODE_USE_OWN_MULTIPLY_PARENT_ALPHA, | integer value | + +|**actor.positionInheritance **| | +|POSITION_INHERITANCE_INHERIT_PARENT_POSITION, | integer value | +|POSITION_INHERITANCE_USE_PARENT_POSITION, | integer value | +|POSITION_INHERITANCE_USE_PARENT_POSITION_PLUS_LOCAL_POSITION, | integer value | +|POSITION_INHERITANCE_DONT_INHERIT_POSITION, | integer value | + +|**actor.drawMode **| | +|DRAW_MODE_NORMAL | integer value | +|DRAW_MODE_OVERLAY | integer value | +|DRAW_MODE_STENCIL | integer value | + +|**Image load policy **| | +|IMAGE_LOAD_POLICY_IMMEDIATE | integer value | +|IMAGE_LOAD_POLICY_ON_DEMAND | integer value | + +|**actor.SetBlendFunc() ** | | +|BLEND_FACTOR_ZERO | integer value | +|BLEND_FACTOR_ONE | integer value | +|BLEND_FACTOR_SRC_COLOR | integer value | +|BLEND_FACTOR_ONE_MINUS_SRC_COLOR | integer value | +|BLEND_FACTOR_SRC_ALPHA | integer value | +|BLEND_FACTOR_ONE_MINUS_SRC_ALPHA | integer value | +|BLEND_FACTOR_DST_ALPHA | integer value | +|BLEND_FACTOR_ONE_MINUS_DST_ALPHA | integer value | +|BLEND_FACTOR_DST_COLOR | integer value | +|BLEND_FACTOR_ONE_MINUS_DST_COLOR | integer value | +|BLEND_FACTOR_SRC_ALPHA_SATURATE | integer value | +|BLEND_FACTOR_CONSTANT_COLOR | integer value | +|BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR | integer value | +|BLEND_FACTOR_CONSTANT_ALPHA | integer value | +|BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA | integer value | + +|**actor.SetBlendMode() **| | +|BLENDING_OFF | integer value | +|BLENDING_AUTO | integer value | +|BLENDING_ON | integer value | + +|**actor.SetBlendEquation() ** | | +|BLEND_EQUATION_ADD | integer value | +|BLEND_EQUATION_SUBTRACT | integer value | +|BLEND_EQUATION_REVERSE_SUBTRACT | integer value | + +|**actor.SetCullFace()** | | +|CULL_FACE_DISABLE | integer value | +|CULL_FRONT_FACE | integer value | +|CULL_BACK_FACE | integer value | +|CULL_FRONT_AND_BACK_FACE | integer value | + +|**actor.sizeMode** | | +|USE_OWN_SIZE | integer value | +|SIZE_EQUAL_TO_PARENT | integer value | +|SIZE_RELATIVE_TO_PARENT | integer value | +|SIZE_FIXED_OFFSET_FROM_PARENT | integer value | + + +|**animation.SetEndAction( mode ) ** | | +|ANIMATION_BAKE | integer value | +|ANIMATION_DISCARD | integer value | +|ANIMATION_BAKE_FINAL | integer value | + +|**camera.type ** | | +|CAMERA_FREE_LOOK | integer value | +|CAMERA_LOOK_AT_TARGET | integer value | + +|**camera.projectionMode ** | | +|CAMERA_PERSPECTIVE_PROJECTION | integer value | +|CAMERA_ORTHOGRAPHIC_PROJECTION | integer value | + + +|** Pixel formats ** | | +| PIXEL_FORMAT_A8 | integer value | +| PIXEL_FORMAT_L8 | integer value | +| PIXEL_FORMAT_LA88 | integer value | +| PIXEL_FORMAT_RGB565 | integer value | +| PIXEL_FORMAT_BGR565 | integer value | +| PIXEL_FORMAT_RGBA4444 | integer value | +| PIXEL_FORMAT_BGRA4444 | integer value | +| PIXEL_FORMAT_RGBA5551 | integer value | +| PIXEL_FORMAT_BGRA5551 | integer value | +| PIXEL_FORMAT_RGB888 | integer value | +| PIXEL_FORMAT_RGB8888 | integer value | +| PIXEL_FORMAT_BGR8888 | integer value | +| PIXEL_FORMAT_RGBA8888 | integer value | +| PIXEL_FORMAT_BGRA8888 | integer value | + +| **Pixel Compressed formats ** | | +| PIXEL_FORMAT_COMPRESSED_R11_EAC | integer value | +| PIXEL_FORMAT_COMPRESSED_SIGNED_R11_EAC | integer value | +| PIXEL_FORMAT_COMPRESSED_RG11_EAC | integer value | +| PIXEL_FORMAT_COMPRESSED_SIGNED_RG11_EAC | integer value | +| PIXEL_FORMAT_COMPRESSED_RGB8_ETC2 | integer value | +| PIXEL_FORMAT_COMPRESSED_SRGB8_ETC2 | integer value | +| PIXEL_FORMAT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 | integer value | +| PIXEL_FORMAT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 | integer value | +| PIXEL_FORMAT_COMPRESSED_RGBA8_ETC2_EAC | integer value | +| PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC | integer value | +| PIXEL_FORMAT_COMPRESSED_RGB8_ETC1 | integer value | +| PIXEL_FORMAT_COMPRESSED_RGB_PVRTC_4BPPV1 | integer value | + + + * @class Constants + */ diff --git a/plugins/dali-script-v8/docs/content/dali.js b/plugins/dali-script-v8/docs/content/dali.js new file mode 100644 index 0000000..578f6ae --- /dev/null +++ b/plugins/dali-script-v8/docs/content/dali.js @@ -0,0 +1,60 @@ +/** + * + +## DALi 3D ( Dynamic Animation Library ) + +DALi is a quick and easy way of allowing developers to create Rich UI Applications like: + + + Image & Video galleries + + Music players + + Games + + Maps + + Homescreens / launch pads + + Advanced watch faces for wearable devices + + +DALi is based on OpenGL ES 2.0 & 3.0, however it hides the complexity of +the OpenGL API from developers and provides a clean cross-platform JavaScript framework. + ++ Create Images, Text and Meshes ++ Create shaders using GLSL ++ Provide multiple cameras and render targets ++ Provides Layers to aid in 2D UI layout ++ Easy to use Animation framework ++ Automatic background loading of resources ( images / text / meshes ) ++ Runs all animations in a seperate thread. This helps maintain 60 FPS even if JavaScript is performing a long operation ( e.g. Garbage Collection ). ++ Provides keyboard / touch / mouse handling + + + + +## Running JavaScript from DALi C++ API +``` +mScript = Dali::Toolkit::Script::New(); + +mScript.ExecuteFile( mScriptFileName); +``` + +## Actors and the Stage + +A DALi application uses a hierachy of Dali::Actor objects to position visible content. An actor inherits a position relative to its parent, and can be moved relative to this point. UI controls can be built by combining multiple actors. + +To display the contents of an actor, it must be connected to the Dali::Stage. This provides an invisible root (top-level) actor, to which all other actors are added. A direct or indirect child of the root actor is considered "on-stage". Multi-touch events are received through signals emitted by on-stage actors. + +The following example shows how to connect a new actor to the stage: +``` + var actor = new dali.actor(); + + dali.stage.add(actor); +``` +## The Coordinate System + +The Stage has a 2D size, which matches the size of the application window. The default coordinate system in DALi has the origin at the top-left corner, with positive X to right, and position Y going +downwards. This is intended to be convenient when laying-out 2D views. + + + + + * @module DALi + * @main DALi + */ diff --git a/plugins/dali-script-v8/docs/content/helpers.js b/plugins/dali-script-v8/docs/content/helpers.js new file mode 100644 index 0000000..78b37c2 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/helpers.js @@ -0,0 +1,5 @@ +module.exports = { + daliName: function() { + return "dali"; + } +}; diff --git a/plugins/dali-script-v8/docs/content/image-actor.js b/plugins/dali-script-v8/docs/content/image-actor.js new file mode 100644 index 0000000..aebe46f --- /dev/null +++ b/plugins/dali-script-v8/docs/content/image-actor.js @@ -0,0 +1,64 @@ +/** +## Image Actor API ( extends Actor API) + +An actor for displaying images. + +Allows the developer to add an actor to stage which displays the content of an Image object. + +By default CullFaceMode is set to CullNone to enable the ImageActor to be viewed from all angles. + +If an ImageActor is created without setting size, then the actor takes the size of the image - +this is the natural size. +Setting a size on the ImageActor, e.g through the SetSize api or through an animation will +stop the natural size being used. + +Such a set size can be changed back to the image's size by calling {{#crossLink "ImageActor/setToNaturalSize:method"}}{{/crossLink}} . + +If a pixel area is set on an ImageActor with natural size, the actor size will change +to match the pixel area. If a pixel area is set on an ImageActor that has had it's size set, +then the size doesn't change, and the partial image will be stretched to fill the set size. + +Clearing the pixel area on an Image actor with natural size will cause the actor to show the +whole image again, and will change size back to that of the image. + +Clearing the pixel area on an Image actor with a set size will cause the actor to show the +whole image again, but will not change the image size. + +### Simple example +``` +var image = new dali.ResourceImage( {url:"background.png"} ); +var imageActor = new dali.ImageActor( image ); + +// by default an actor is anchored to the top-left of it's parent actor +// change it to the middle +imageActor.parentOrigin = dali.CENTER; + +// scale it up by 2 times in x,y +imageActor.scale = [ 2, 2, 1 ]; + +// add to the stage +dali.stage.add( imageActor ); +``` + +### Example using a pixel area ( needed for displaying images from a Texture Atlas ) + +``` +var imageAtlas = new dali.ResourceImage( {url:"atlas.png"} ) +``` + + +### Image Actor Specific Properties + + +|Name | Type | Writable | Animatable| +|-----------------------|------------|--------------|-----------| +| pixelArea | RECTANGE | ✔ | ✘ | +| fadeIn | BOOLEAN | ✔ | ✘ | +| fadeInDuration | FLOAT | ✔ | ✘ | +| style | dali.IMAGE_ACTOR_STYLE_QUAD, dali.IMAGE_ACTOR_STYLE_NINE_PATCH, dali.IMAGE_ACTOR_STYLE_NINE_PATCH_NO_CENTER | ✔ | ✘ | +| border | VECTOR4 | ✔ | ✘ | + + +@class ImageActor +@extends RenderableActor + */ \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/image.js b/plugins/dali-script-v8/docs/content/image.js new file mode 100644 index 0000000..5d06d3e --- /dev/null +++ b/plugins/dali-script-v8/docs/content/image.js @@ -0,0 +1,75 @@ +/** + * +## Image API + +An Image object represents a resource that can be added to ImageActors and ShaderEffects. + +The image is discarded when all ImageActors using the Image object are discarded or in case they +were created with dali.IMAGE_RELEASE_POLICY_UNUSED, taken off stage. + +Note: if a resource was shared between Image objects it exists until its last reference is gone. + +Image objects are responsible for the underlying resource's lifetime. + +### ReleasePolicies + + - dali.IMAGE_RELEASE_POLICY_UNUSED: release resource once ImageActor using it is taken off stage. + - dali.IMAGE_RELEASE_POLICY_NEVER: keep resource alive until Image object is thrown away ( default). + +#### Resolution of conflicting policies + - If the same image is created more than once with conflicting policies, ReleasePolicy "Never" overrides "Unused". + + +### The hierarchy of Image is: + +- {{#crossLink "image"}}Image base class {{/crossLink}} provides basic functionality + - {{#crossLink "ResourceImage"}}ResourceImage {{/crossLink}} used for loading image files and nine-patch files + - {{#crossLink "NinePatchImage"}}NinePatch {{/crossLink}} used just for nine patch files + - {{#crossLink "BufferImage"}}BufferImage {{/crossLink}} used for generating your own image + - {{#crossLink "FrameBufferImage"}}FrameBufferImage {{/crossLink}} contains the result of an 'off screen' render pass of a RenderTask. + - {{#crossLink "NativeImage"}}NativeImage {{/crossLink}} Its data is provided by native resources, such as shared bitmap memory or pixmap from X11 or ECORE-X11, etc. + + +### Example: +``` +var image = new dali.ResourceImage( {url: "background.png"} ); + +var imageActor1 = new dali.ImageActor( image ); +var imageActor2 = new dali.ImageActor( image ); + +shaderEffect.setEffectImage( image ); + + +``` +The API supports functionality such as: + ++ {{#crossLink "image/Image:method"}}new dali.ResourceImage{{/crossLink}} ++ {{#crossLink "image/getWidth:method"}}{{/crossLink}} ++ {{#crossLink "image/getHeight:method"}}{{/crossLink}} + +### 9 patch images + +The Image class also has support for loading 9 patch Images if the filename contains .9. +e.g. +``` +var blackFrame = new dali.ResourceImage( url:"black-frame.9.png"}); +var borderNinePatch = new dali.ResourceImage( {url:"border.9.png"} ); +// or if the image doesn't have a .9 filename, you can use the NinePatchImage class +var image = new dali.NinePatchImage( {url:"my_image.png"}) +``` +The nine patch image will scale automatically with the size of the actor. + +Tool for making 9 patches + + http://romannurik.github.io/AndroidAssetStudio/nine-patches.html + +More information on them: + + http://radleymarx.com/blog/simple-guide-to-9-patch/ + + http://developer.android.com/tools/help/draw9patch.html + + + + @class Image + */ diff --git a/plugins/dali-script-v8/docs/content/keyboard-focus-manager.js b/plugins/dali-script-v8/docs/content/keyboard-focus-manager.js new file mode 100644 index 0000000..465e249 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/keyboard-focus-manager.js @@ -0,0 +1,66 @@ +/** + * + +## Keyboard Focus Manager API + +Keyboard focus manager controls the keyboard focus flow. + +It also allows you to set an actor that is used to high light the focused actor. + +{{#crossLink "KeyboardFocusManager/setFocusIndicatorActor:method"}}{{/crossLink}} + +The application is required to help the manager when moving focus. + + + +### keyboard-pre-focus-change + +Connect to the pre-focus-change call back as follows: +``` +// listen for pre-focus change events +dali.keyboardFocusManager.connect("keyboard-pre-focus-change", this.preFocusChanged); + +// example call back handler + +// currentFocusedActor = currently focused actor +// proposed = keyboard focus managers guess at what actor should be next +// direction = the direction of the focus is moving in +// +myApp.preFocusChanged = function( currentFocusedActor, proposedActorToFocus, direction) +{ + + if (direction == "up" ) + { + return actor above current actor; + } + if (direction == "right" ) + { + return actor to the right of current actor; + } +} + +dali.keyboardFocusManager.connect("keyboard-pre-focus-change", myCallback) +``` + +KeyboardFocusManager makes the best guess for which actor to focus towards the given direction, but applications might want to change that. + +By connecting with this signal, they can check the proposed actor to focus and return a different actor if they wish. + +This signal is only emitted when the navigation key is pressed and KeyboardFocusManager tries to move the focus automatically. + +It won't be emitted for focus movement by calling setCurrentFocusActor directly. + +### keyboard-focus-changed + +This signal is emitted after the current focused actor has been changed. +``` +myCallback( originalFocusedActor, currentFocusedActor) +{ +} + +dali.keyboardFocusManager.connect("keyboard-focus-change", myCallback) +``` + +@class KeyboardFocusManager + + */ diff --git a/plugins/dali-script-v8/docs/content/layer-actor.js b/plugins/dali-script-v8/docs/content/layer-actor.js new file mode 100644 index 0000000..bcbf696 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/layer-actor.js @@ -0,0 +1,45 @@ +/** +## Layer Actor API ( extends Actor API) + + Layers provide a mechanism for overlaying groups of actors on top of each other. + + When added to the stage, a layer can be ordered relative to other layers. The bottom + layer is at depth zero. The stage provides a default layer for it's children. + + Layered actors inherit position etc. as normal, but are drawn in an order determined + by the layers. The depth buffer is cleared before each layer is rendered unless depth + test is disabled or there's no need for it based on the layers contents; + actors in lower layers cannot obscure actors in higher layers. + + If depth test is disabled, there is no performance overhead from clearing the depth buffer. + + +### Simple example + +``` + +var textActor1 = new dali.TextActor( "I'm above" ); +var textActor2 = new dali.TextActor( "I'm below" ); + +// add first actor to the stage +dali.stage.add( textActor1 ); + +// create a layer and add second actor +var layer = new dali.Layer(); +layer.add( textActor2 ); +dali.stage.add( layer ); // textActor2 is now above textActor1 + +// shift layer to bottom +layer.lowerToBottom(); // textActor2 is now below textActor1 +``` + +### Layer Actor Specific Properties + +| Name | Type | Writable | Animatable| +|------------------------|------------|--------------|-----------| +| clippingEnabled |BOOLEAN | ✔ | ✘ | +| clippingBox | RECTANGLE ([0,0,400,600]) | ✔ | ✘| + + @class Layer + @extends Actor + */ diff --git a/plugins/dali-script-v8/docs/content/module-loader.js b/plugins/dali-script-v8/docs/content/module-loader.js new file mode 100644 index 0000000..181d8dc --- /dev/null +++ b/plugins/dali-script-v8/docs/content/module-loader.js @@ -0,0 +1,8 @@ +/** + ## Module loader + + See {{#crossLink "ModuleLoader/require:method"}}{{/crossLink}} + + @class ModuleLoader + */ + diff --git a/plugins/dali-script-v8/docs/content/pan-gesture-detector.js b/plugins/dali-script-v8/docs/content/pan-gesture-detector.js new file mode 100644 index 0000000..3285651 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/pan-gesture-detector.js @@ -0,0 +1,41 @@ +/** + * +## PanGestureDetector API + + +PanGestureDetector analyse a stream of touch events and looks for panning (or dragging) gestures. +If an actor is attached to the pan gesture detector, the detector will emit a detected signal to +the application when it recognises a pan gesture on the attached actor in its analysis. + +### Simple example + +``` +// Create a pan gesture detector +var panGestureDetector = new dali.PanGestureDetector(); + +var actor = new dali.Actor(); +dali.stage.add(actor); + +// Attach an actor to the detector +panGestureDetector.attach(actor); + +// Connect the detected signal +panGestureDetector.connect("pan-detected", onPan); + +onPan = function(actor, panGesture) +{ + log("Pan gesture state: " + panGesture.state + ", number of touches: " + panGesture.numberOfTouches + ", time stamp: " + panGesture.time + "\n"); + log("local position: " + panGesture.position.x + ", " + panGesture.position.y + "\n"); + log("local displacement: " + panGesture.displacement.x + ", " + panGesture.displacement.y + "\n"); + log("local velocity: " + panGesture.velocity.x + ", " + panGesture.velocity.y + "\n"); + log("screen position: " + panGesture.screenPosition.x + ", " + panGesture.screenPosition.y + "\n"); + log("screen displacement: " + panGesture.screenDisplacement.x + ", " + panGesture.screenDisplacement.y + "\n"); + log("screen velocity: " + panGesture.screenVelocity.x + ", " + panGesture.screenVelocity.y + "\n"); +} + +// Detach the actor from the detector +panGestureDetector.detach(actor); +``` +@class PanGestureDetector + +*/ \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/path-animation.js b/plugins/dali-script-v8/docs/content/path-animation.js new file mode 100644 index 0000000..36d7986 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/path-animation.js @@ -0,0 +1,46 @@ +/** + * +## Path Animation API + +Paths can be used to animate position and orientation of actors. + + + +Example + +``` +log("Path animation test\n"); + +var point0 = [ 0.0, 80.0, 0.0 ]; +var point1 = [ 200.0, 200.0, 0.0 ]; +var point2 = [ 400.0, 80.0, 0.0 ]; + +//Create a path +var myPath = new dali.Path(); +myPath.points = [ point0, point1, point2 ]; +myPath.generateControlPoints( 0.25 ); + +function begin() +{ + + var image = new dali.ResourceImage( {url:"gallery-small-45.jpg"} ); + + var actor = new dali.ImageActor(image); + + actor.position = [100,100,0]; + dali.stage.add( actor ); + + var animation = new dali.Animation(2.0); + var animOptions = { alpha:"easeInOutSine", delay:0.5, duration:1.5 }; + var forward = new dali.Vector3(1,0,0); + animation.animate( actor, myPath, forward, animOptions ); + + animation.setLooping( true ); + animation.play(); +} + +begin(); +``` +@class Path + +*/ \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/render-task.js b/plugins/dali-script-v8/docs/content/render-task.js new file mode 100644 index 0000000..c410fdf --- /dev/null +++ b/plugins/dali-script-v8/docs/content/render-task.js @@ -0,0 +1,87 @@ +/** + * + +## RenderTask API + + +RenderTasks describe how the Dali scene should be rendered. + +The {{#crossLink "Stage/getRenderTaskList:method"}}{{/crossLink}} method provides access to an ordered list of render-tasks. + +Each RenderTask must specify the source actors to be rendered, and a camera actor from +which the scene is viewed. + + +RenderTasks may optionally target a frame-buffer, otherwise the default GL surface is used; +typically this is a window provided by the native system. + + +By default Dali provides a single RenderTask, which renders the entire actor hierachy using +a default camera actor and GL surface. If stereoscopic rendering is enabled, Dali will create +two additional render tasks, on for each eye. Each render task will have its own camera parented +to the default camera actor. + +The first RenderTask used for input handling will be the last one rendered, which also has input enabled, +and has a valid source & camera actor; see {{#crossLink "RenderTask/setInputEnabled:method"}}{{/crossLink}}. + +If none of the actors are hit in the last RenderTask rendered, then input handling will continue +with the second last RenderTask rendered, and so on. + +All RenderTasks which target a frame-buffer (i.e. off screen) will be rendered before all RenderTasks +which target the default GL surface. This allows the user to render intermediate targets which are used +later when targetting the screen. + +A RenderTask targetting a frame-buffer can still be hit-tested, provided that the +screen->frame-buffer coordinate conversion is successful; see SetScreenToFrameBufferMappingActor(). +``` +var tasklist = dali.stage.getRenderTaskList(); + +var renderTask0 = tasklist.createTask(); + +renderTask0.setSourceActor( myActor ); +renderTask0.setClearEnabled( true ); +renderTask0.clearColor = [1.0,0.0,0.0,0.0]; + +renderTask0.clearColor = [1.0,0.0,0.0,0.0]; + +var camera = new dali.CameraActor(); + +renderTask0.setCameraActor( camera ); +``` + +### Render Task Specific Properties + + +| Name | Type | Writable | Animatable| +|------------------------|------------|--------------|-----------| +|viewportPosition | VECTOR2 | ✔ | ✘ | +|viewportSize | VECTOR2 | ✔ | ✘ | +|clearColor | VECTOR4 | ✔ | ✘ | + + +@class RenderTask +*/ + +/** + * View port position + * + * @property viewportPosition + * @type dali Vector2 + */ +viewportPosition + +/** + * View port size + * + * @property parentOrigin + * @type dali Vector3 + */ +viewportSize + + /** + * clear color + * + * @property clearColor + * @type dali Vector4 + */ + clearColor \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/renderable-actor.js b/plugins/dali-script-v8/docs/content/renderable-actor.js new file mode 100644 index 0000000..add11aa --- /dev/null +++ b/plugins/dali-script-v8/docs/content/renderable-actor.js @@ -0,0 +1,17 @@ +/** + * + *

Renderable Actor ( Extends Actor API )

+ * Renderable actors are actors that can be drawn. + * These currently are: + * - {{#crossLink "ImageActor"}}{{/crossLink}} + * - {{#crossLink "TextActor"}}{{/crossLink}} + * - {{#crossLink "MeshActor"}}{{/crossLink}} + * + * @class RenderableActor + * @extends Actor + */ + + + + + diff --git a/plugins/dali-script-v8/docs/content/resource-image.js b/plugins/dali-script-v8/docs/content/resource-image.js new file mode 100644 index 0000000..618f3cf --- /dev/null +++ b/plugins/dali-script-v8/docs/content/resource-image.js @@ -0,0 +1,43 @@ +/** + * +## ResourceImage (extends Image) + +A resource image extends the basic {{#crossLink "image"}}Image class{{/crossLink}} with +the ability to load an image from a file. + +ResourceImage supports two types of load policies + +- dali.IMAGE_LOAD_POLICY_IMMEDIATE // load image once it is created (default) +- dali.IMAGE_LOAD_POLICY_ON_DEMAND // delay loading until the image is being used (a related actor is added to Stage) + +### Simple example +``` + +var image = new dali.ResourceImage( { url:"my_image.png" } ); + +var imageActor = new dali.ImageActor( image ); + +``` +### Advanced example +``` + +function imageLoaded( image ) +{ + log("image loaded " +image.url + "\n"); +} + +var options = { + url:"my_image.png", + loadPolicy:dali.IMAGE_LOAD_POLICY_IMMEDIATE, + releasePolicy: dali.IMAGE_RELEASE_POLICY_UNUSED +} +var image = new dali.ResourceImage( options ); + +image.connect("image-loading-finished", finished ); + +var imageActor = new dali.ImageActor( image ); + +``` +@class ResourceImage +@extends Image + */ \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/shader-effect.js b/plugins/dali-script-v8/docs/content/shader-effect.js new file mode 100644 index 0000000..ea1eba8 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/shader-effect.js @@ -0,0 +1,259 @@ +/** + * + +## Shader Effects API + +Shader effects provide a visual effect for actors. + +For a Custom shader you can provide the vertex and fragment shader code as strings. +Each shader is provided with default uniforms and attributes. +For a vertex shader this part contains the following code: +``` +precision highp float; +attribute vec3 aPosition; +attribute vec2 aTexCoord; +uniform mat4 uMvpMatrix; +uniform mat4 uModelMatrix; +uniform mat4 uViewMatrix; +uniform mat4 uModelView; +uniform mat3 uNormalMatrix; +uniform mat4 uProjection; +uniform vec4 uColor; +varying vec2 vTexCoord; +``` +The custom shader part is expected to output the vertex position and texture coordinate. +A basic custom vertex shader would contain the following code: +``` +void main() +{ + gl_Position = uProjection * uModelView * vec4(aPosition, 1.0); + vTexCoord = aTexCoord; +} +``` +For an Image fragment shader the default attributes and uniforms are: +``` +precision mediump float; +uniform sampler2D sTexture; +uniform sampler2D sEffect; +uniform vec4 uColor; +varying vec2 vTexCoord; +``` +The custom shader is expected to output the fragment color. +The basic fragment shader for images would contain: +``` +void main() +{ + gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor; +} +``` +The API supports functionality such as: + ++ new dali.{{#crossLink "ShaderEffect/ShaderEffect:method"}}{{/crossLink}} ++ {{#crossLink "ShaderEffect/setUniform:method"}}{{/crossLink}} + +### Example of using a custom uniform to brighten an Image (Fragment Shader) + + +``` +createColorEffect = function() +{ + + // add uColorShift to the pixel color + + var fragShader = + "uniform lowp vec4 uColorShift; \ + \ + void main() \ + { \ + gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor + uColorShift; \ + }" + + var shaderOptions = { + geometryType: "image", + fragmentShader: fragShader + }; + + // create a new shader effect + var shader = new dali.ShaderEffect(shaderOptions); + + // add the color shift uniform so we can modify and animate it + shader.setUniform("uColorShift", [0.0, 0.0, 0.0, 0]); + return shader; +} +// create an image actor and add an image to it +var image = new dali.ResourceImage( { url: getImageDirectory() +"gallery-medium-50.jpg"}); +var imageActor = new dali.ImageActor( image ); +imageActor.parentOrigin = dali.CENTER; +dali.stage.add( imageActor ); + +var colorShift = createColorEffect(); + +colorShift.setUniform( "uColorShift", [0.5,0.5,0.5,0.0] ); // increase RGB by 50% + +imageActor.setShaderEffect( colorShift ); +``` + +For an example of animating we can just do: +``` +var shaderAnim = new dali.Animation(10); + +var animOptions = { + alpha: "doubleEaseInOutSine60", +}; + +// animate the color uniform to full white +shaderAnim.animateTo( colorShift, "uColorShift", dali.COLOR_WHITE, animOptions); + +shaderAnim.play(); +``` +Like all animatable properties we can also use keyframes to animate the value. +* * * + +### Example of animating a custom uniform to perform a mask operation (Fragment Shader) + +In this example we are using the OpenGL discard function to draw an image with a circular mask. + + +``` +createRevealEffect = function() +{ +// texture co-ordinate is from 0..1 +// we shift the texture co-ordinate to -0.5 to 0.5 to center it +// then work out the radius from the centre, using ( a^2 + b^2) = c^2 +// we use the dot product to perform the a^2 + b^2 +// then just perform uRadius * uRadius to workout c^2 + + var fragShader = + " uniform lowp float uRadius; \ + \ + void main() \ + { \ + lowp vec2 pos= vec2(vTexCoord.x-0.5,vTexCoord.y-0.5); \ + lowp float radius = dot(pos, pos ) ; \ + if( radius > (uRadius*uRadius) )\ + discard; \ + gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor ; \ + }" + + var shaderOptions = { + geometryType: "image", + fragmentShader: fragShader + }; + + // create a new shader effect + var shader = new dali.ShaderEffect(shaderOptions); + + // set the uniform + shader.setUniform("uRadius",0.0); + return shader; +} +// create an image actor and add an image to it +var filename = getImageDirectory() +"gallery-medium-50.jpg; +var image = new dali.ResourceImage( {url: filename }); +var imageActor = new dali.ImageActor( image ); +imageActor.parentOrigin = dali.CENTER; +dali.stage.add( imageActor ); + +var revealEffect = createRevealEffect(); + +imageActor.setShaderEffect( revealEffect ); + +var shaderAnim = new dali.Animation(5); + +var animOptions = { + alpha: "easeInOutSine", + }; + +// animate up to radius = 0.5 ( a full circle ) +// if we go to 1.0 then it will go to a full box +shaderAnim.animateTo( revealEffect, "uRadius", 0.5,animOptions); +shaderAnim.play(); + +* * * +### Example of paper twisting in the wind with color (Vertex + Fragment Shader) + +
+ +The example does the following: + ++ Creates a varying variable called vColor in the vertex shader. + + The vColor is set to the position of the vertex, so the color changes depending on its position ++ Create a uniform called uOffset which modifies the xPosition of each vertex, creating a twist effect + +An ImageActor normally only has 4 vertices ( quad ). To allow the image to twist and bend we need it to have more +vertices. To do this we can break the image into a grid using the gridX and gridY geometry hints. + + + + +createTwistEffect = function() +{ + + // do some maths on the x-position to move it based on y,z pos + uOffset + var vertexShader = + " \ + varying lowp vec4 vColor; \ + uniform lowp float uOffset; \ + \ + void main() \ + { \ + vec4 pos = uProjection * uModelView * vec4(aPosition, 1.0); \ + pos.x= 3*pos.z*(sin(1.57+uOffset+pos.y/1000.0)); \ + gl_Position =pos; \ + vColor = pos/500.0;\ + vTexCoord = aTexCoord; \ + }" + + // add the vColor to the pixel color to tint it + var fragShader = + " \ + varying lowp vec4 vColor; \ + void main() \ + { \ + gl_FragColor = texture2D( sTexture, vTexCoord ) *uColor + vColor*0.2; \ + }" + + var shaderOptions = { + geometryType: "image", + vertexShader: vertexShader, + fragmentShader: fragShader, + geometryHints: ["grid"] + }; + + // create a new shader effect + var shader = new dali.ShaderEffect(shaderOptions); + + // set the uniform + shader.setUniform("uOffset",0.0); + return shader; +} + + +dali.stage.setBackgroundColor( dali.COLOR_WHITE); + +var image = new dali.ResourceImage( { url:getImageDirectory() +"gallery-medium-50.jpg"}); +var imageActor = new dali.ImageActor( image ); +imageActor.parentOrigin = dali.CENTER; +imageActor.setCullFace( dali.CULL_FACE_DISABLE ); // disable face culling so we can see both sides +dali.stage.add( imageActor ); + +// start it of tilted around the y-axis +imageActor.rotation=new dali.Rotation(90, 0, 1, 0); + +var twistEffect = createTwistEffect(); +imageActor.setShaderEffect( twistEffect ); + +var shaderAnim = new dali.Animation(1); +var animOptions = { + alpha: "bounce", + duration:20 + }; +shaderAnim.animateTo( twistEffect, "uOffset",20,animOptions); + +shaderAnim.play(); +``` +Note: In order for fade and color animations to work, the fragment shader needs to multiply the fragment color +with the uniform color "uColor" of the node + +@class ShaderEffect +*/ \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/stage.js b/plugins/dali-script-v8/docs/content/stage.js new file mode 100644 index 0000000..dcacca6 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/stage.js @@ -0,0 +1,67 @@ +/** +## Stage API + +The Stage is a top-level object used for displaying a tree of Actors. + + - Stage is a static object used by accessing the dali.stage object. + - Stage provides a top-level "root" actor. + - Stage provides Key Events to the application + - Stage has a background color you can set, see {{#crossLink "stage/setBackgroundColor:method"}}{{/crossLink}} + +When an actor is not required, remove it from the stage to save memory and help performance. +``` +dali.stage.setBackgroundColor( dali.COLOR_WHITE); + +var stageSize = dali.stage.getSize(); + +var imageActor = new dali.ImageActor( ); + +dali.stage.add( imageActor ); + +// when the actor is no longer required +dali.stage.remove( imageActor ); +``` + + + +### Key Events + +Key events are received through the key-event callback. + +``` +daliApp.myCallback = function (keyEvent) +{ + switch (keyEvent.keyDescription) { + case "Up": log("up"); + break; + + case "Down": log("down"); + break; + + case "Left": log("left"); + break; + + case "Right": log("right"); + break; + + } +} + +dali.stage.connect("key-event", daliApp.myCallback); +``` + +The key event object has the following properties +``` + KeyEvent = { + state, // boolean = "down" or "up" key state + shiftPressed, // boolean, shift key is held + ctrlPressed, // boolean, ctrl key is held + altPressed, // boolean, alt key is held + keyModifiers, // key modifiers + keyCode, // key code + keyDescription, // key description + timestamp // The time in milli-seconds when the event occured + } +``` + @class Stage +*/ \ No newline at end of file diff --git a/plugins/dali-script-v8/docs/content/text-actor.js b/plugins/dali-script-v8/docs/content/text-actor.js new file mode 100644 index 0000000..7aa2b04 --- /dev/null +++ b/plugins/dali-script-v8/docs/content/text-actor.js @@ -0,0 +1,79 @@ +/** +## Text Actor API +TextActor is a basic actor for displaying a text label + +By default the text actor always uses the natural size of the text, when the text property is set, +unless SetSize is called to override the size or size is animated to some other size. + +Natural size for TextActor is the same as the size returned by dali.font.MeasureText( string ) +using the font that the TextActor is using. + +By default {{#crossLink "RenderableActor/setCullFace:method"}}CullFaceMode{{/crossLink}} is set to CullNone to enable the TextActor to be viewed from all angles. + +### Simple example +``` +var textActor = new dali.TextActor( "Hello world" ); + +// by default an actor is anchored to the top-left of it's parent actor +// change it to the middle +textActor.parentOrigin = [0.5,0.5,0.5]; + +// scale it up by 4 times in x,y +textActor.scale = [ 4, 4, 1 ]; + +// add to the stage +dali.stage.add( textActor ); +``` + +### Example using a font and text options ### +``` +var fontInfo = +{ + family : "Arial", + style :"Bold", + pointSize:20 +} + +var arialFont = new dali.Font( fontInfo ); +var textOptions = +{ + font: arialFont, + isRightToLeft: true, + fontDetection: true // default is true +} + +var textActor1 = new dali.TextActor( "Hello-world" , textOptions ); + +// this will automatically chose a different font that can display the text +var textActor2 = new dali.TextActor( "繁體中文" , textOptions ); +``` + +| Name | Type | Writable | Animatable| +|------------------------|------------|--------------|-----------| +| text | STRING | ✔ |✘ | +| font | STRING | ✔ |✘ | +| font-style | STRING | ✔ |✘ | +| outline-enable | BOOLEAN | ✔ |✘ | +| outline-color | VECTOR4 | ✔ |✘ | +| outline-thickness-width| VECTOR2 | ✔ |✘ | +| smooth-edge | FLOAT | ✔ |✘ | +| glow-enable | BOOLEAN | ✔ |✘ | +| glow-color | VECTOR4 | ✔ |✘ | +| glow-intensity | FLOAT | ✔ |✘ | +| shadow-enable | BOOLEAN | ✔ |✘ | +| shadow-color | VECTOR4 | ✔ |✘ | +| shadow-offset | VECTOR2 | ✔ |✘ | +| italics-angle | FLOAT | ✔ |✘ | +| underline | BOOLEAN | ✔ |✘ | +| weight | INTEGER | ✔ |✘ | +| font-detection-automati| BOOLEAN | ✔ |✘ | +| gradient-color | VECTOR4 | ✔ |✘ | +| gradient-start-point | VECTOR2 | ✔ |✘ | +| gradient-end-point | VECTOR2 | ✔ |✘ | +| shadow-size | FLOAT | ✔ |✘ | +| text-color | VECTOR4 | ✔ |✘ | + +@class TextActor +@extends RenderableActor + */ + diff --git a/plugins/dali-script-v8/docs/content/texture-atlases.js b/plugins/dali-script-v8/docs/content/texture-atlases.js new file mode 100644 index 0000000..7005fca --- /dev/null +++ b/plugins/dali-script-v8/docs/content/texture-atlases.js @@ -0,0 +1,149 @@ +/** + * + +## Using Texture Atlases in DALi + + +### Example demo application + + + + +### Application above is running slow as there are many small individual images displayed (50) + + + + + + + + + + + + + + + + + + +
Launch Time Slow Has to perform:
- 50 file open requests and multiple reads for each image
Memory Usage High Has to create: +
- 50 Dali::Image objects +
- 50 OpenGL Textures +
Rendering Performance Slow Has to perform: +
- 50 glBindTexture calls per frame ( each OpenGL calls takes time) +
- 50 a frame = 3000 calls per second @60 FPS. +
- Texture switching is a major state change in the GPU +
+

+ + +### Solutions to problem: Use a Texture Atlas + +A texture atlas is simply one larger image that contains smaller images.
+A texture atlas is sometimes called a sprite sheet, bitmap sheet or texture pack. +

+ +

+Dali::ImageActor has the ability to display a portion of an image using ImageActor::PixelArea setting. +For example to display the first 3 image in the atlas +

+``` +var imageAtlas = new dali.ResourceImage( {url:"atlas.png"} ) +``` + +
+### Result of using an Atlas + + + + + + + + + + + + + + + + +
Launch Time Fast Has to perform:
- 1 file open request
Memory Usage Better Has to create: +
- 1 Dali::Image objects +
- 1 OpenGL Textures +
Rendering Performance Fast Has to perform: +
- 1 glBindTexture calls per frame ( each OpenGL calls takes time) +
- 1 a frame = 6- calls per second @60 FPS. +
+
+## Atlas creation guide + +Many tools exist for creating texture atlases.
+In the following example we are using a tool called TexturePacker as DALi has an exporter script for it. +The exporter automatically generates a source file that has the ImageActor::PixelArea pre-defined. +
+ ++ Download http://www.codeandweb.com/texturepacker ++ Launch TexturePacker ++ Go to the menu File -> Preferences ++ Set the "Exporter directory" to be the location of dali-toolkit/texture-atlas-exporter
+ +
++ Restart the application! ++ Select DALi 3D framework for new project + +
++

Create the atlas

+ ++

Click publish to produce the files



+ + +## Using the generated cpp file + +The generated cpp file contains 3 different ways of describing the atlas. +2 ways are designed for the DALi C++ API, the 3rd way is for JavaScript. +Example exported property map from TexturePacker: +``` +var ATLAS_IMAGE_LIST : [ + { name: "add_user_usericon_bg", x: 2, y:109, w:105, h:105, dali.BLENDING_ON }, + { name: "app_background", x: 180, y:183, w:1, h:1, dali.BLENDING_OFF }, + { name: "btn_arrow_left", x: 141, y:183, w:11, h:20, dali.BLENDING_ON }, + { name: "btn_arrow_right", x: 154, y:183, w:11, h:20, dali.BLENDING_ON }, + { name: "icn_app_foc", x: 194, y:2, w:72, h:72, dali.BLENDING_ON }, + { name: "icn_app_nor", x: 109, y:109, w:72, h:72, dali.BLENDING_ON } + ] +var atlas = new dali.ResourceImage( { url: "atlas_filename.png" }); + +// display the user icon using the size / position data in the ATLAS_IMAGE_LIST +var userIconData = ATLAS_IMAGE_LIST[0]; +var userIconRect = [ userIconData.x, userIconData.y,userIconData.w,userIconData.h]; + +var btnArrowLeft = new dali.ImageActor( atlas, userIconRect ); +``` + +## Atlas creation tips + + + - Compress the atlas + - Avoid adding large images to the Atlas. + E.g. don't add background images to it. Medium to large images should + be kept seperate.

+ + + - Try to ensure the atlas contains only images that are frequently used.
+ There's no point in having images taking up GPU texture memory if they're not displayed.
+ + - Avoid very large atlases
+ Try to create multiple atlases based on how they are used within your application.
+
+ Alternatively Texture packer has the option to split atlases ( search help for Multipack) + - + + + + @class TextureAtlases + */ + diff --git a/plugins/dali-script-v8/docs/content/texture-compression.js b/plugins/dali-script-v8/docs/content/texture-compression.js new file mode 100644 index 0000000..4d9588f --- /dev/null +++ b/plugins/dali-script-v8/docs/content/texture-compression.js @@ -0,0 +1,58 @@ + +/** + * + +## Texture Compression + +Using compressing the textures will: + +- Speed up rendering in time the GPU == less power used due to less texture data being transferred. +- Reduce texture memory usage. +- Speed up load times. Smaller files mean quicker load times. + +DALi supports the KTX file format. +You just load the compressed texture like you would any other image. + + var image = new dali.ResourceImage({url:"my_compressed_file.ktx"}); + +ARMS texture compression tool
+http://malideveloper.arm.com/develop-for-mali/tools/asset-creation/mali-gpu-texture-compression-tool/
+ +Here is an example of using the ARM compression tool. + + + + + +As shown above the ETC-1 compression format does not support alpha.
As a work around the tool will export +the alpha as a seperate compressed image. +In order to combine both the images you need to use a custom shader. +Here is an example shader: +``` +var fragSource = " \ +void main() \ +{ \ + vec4 v4Color = (texture2D(sTexture, vTexCoord) * uColor); \ + v4Color.a = texture2D(sEffect, vTexCoord ).r; \ + gl_FragColor = v4Color; \ +}"; + +var shaderEffect = new dali.ShaderEffect( "", fragSource); + +var atlasImageRGB = new dali.ResourceImage( { url:"ATLAS_RGB_FILENAME.KTX"} ); + +var atlasImageAlpha = new dali.ResourceImage( { url:"ATLAS_ALPHA_FILENAME.KTX"} ); + +shaderEffect.setEffectImage( atlasImageAlpha ); + +// to create Image Actor +ImageActor imageActor = ImageActor::New( mAtlasImageRGB, GetImagePosition( info) ); + +imageActor.setShaderEffect( shaderEffect ); + +imageActor.setBlendMode( dali.BLENDING_ON ); +``` + @class TextureCompression + + + */ diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/css/external-small.png b/plugins/dali-script-v8/docs/dali-theme/assets/css/external-small.png new file mode 100644 index 0000000000000000000000000000000000000000..759a1cdcb5b1697e5be290d98b830e279cd71f3c GIT binary patch literal 491 zcmVDs{zR1^XE?tfB*h@ASKHAa7wwn{MEbP z7_^nS7{V*>+A}bS;P%45fB%Ai|Neasi2rl3{=EO;!w318%8Ovl7jArHc=P5Brfr~D z0AYimtss2w$hlYlfd>7*aO3TNzw875LBK0xAD9Np|A(oEVYnB*eE9~V6wP%78SXuL z&#-X)Er#`zY#Ce)^8hM>B_8 literal 0 HcmV?d00001 diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/css/logo.png b/plugins/dali-script-v8/docs/dali-theme/assets/css/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..eda5c9f81c9c4c036732d2f36fafe81e0e7bbb96 GIT binary patch literal 11599 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
+   blocks. */
+pre code, pre kbd, pre samp { font-size: 100%; }
+
+/* Used to denote text that shouldn't be selectable, such as line numbers or
+   shell prompts. Guess which browser this doesn't work in. */
+.noselect {
+    -moz-user-select: -moz-none;
+    -khtml-user-select: none;
+    -webkit-user-select: none;
+    -o-user-select: none;
+    user-select: none;
+}
+
+/* -- Lists ----------------------------------------------------------------- */
+dd { margin: 0.2em 0 0.7em 1em; }
+dl { margin: 1em 0; }
+dt { font-weight: bold; }
+
+/* -- Tables ---------------------------------------------------------------- */
+caption, th { text-align: left; }
+
+table {
+    border-collapse: collapse;
+    width: 100%;
+}
+
+td, th {
+    border: 1px solid #fff;
+    padding: 5px 12px;
+    vertical-align: top;
+}
+
+td { background: #E6E9F5; }
+td dl { margin: 0; }
+td dl dl { margin: 1em 0; }
+td pre:first-child { margin-top: 0; }
+
+th {
+    background: #D2D7E6;/*#97A0BF*/
+    border-bottom: none;
+    border-top: none;
+    color: #000;/*#FFF1D5*/
+    font-family: 'Trebuchet MS', sans-serif;
+    font-weight: bold;
+    line-height: 1.3;
+    white-space: nowrap;
+}
+
+
+/* -- Layout and Content ---------------------------------------------------- */
+#doc {
+    margin: auto;
+    min-width: 1024px;
+}
+
+.content { padding: 0 20px 0 25px; }
+
+.sidebar {
+    padding: 0 15px 0 10px;
+}
+#bd {
+    padding: 7px 0 130px;
+    position: relative;
+    width: 99%;
+}
+
+/* -- Table of Contents ----------------------------------------------------- */
+
+/* The #toc id refers to the single global table of contents, while the .toc
+   class refers to generic TOC lists that could be used throughout the page. */
+
+.toc code, .toc kbd, .toc samp { font-size: 100%; }
+.toc li { font-weight: bold; }
+.toc li li { font-weight: normal; }
+
+/* -- Intro and Example Boxes ----------------------------------------------- */
+/*
+.intro, .example { margin-bottom: 2em; }
+.example {
+    -moz-border-radius: 4px;
+    -webkit-border-radius: 4px;
+    border-radius: 4px;
+    -moz-box-shadow: 0 0 5px #bfbfbf;
+    -webkit-box-shadow: 0 0 5px #bfbfbf;
+    box-shadow: 0 0 5px #bfbfbf;
+    padding: 1em;
+}
+.intro {
+    background: none repeat scroll 0 0 #F0F1F8; border: 1px solid #D4D8EB; padding: 0 1em;
+}
+*/
+
+/* -- Other Styles ---------------------------------------------------------- */
+
+/* These are probably YUI-specific, and should be moved out of Selleck's default
+   theme. */
+
+.button {
+    border: 1px solid #dadada;
+    -moz-border-radius: 3px;
+    -webkit-border-radius: 3px;
+    border-radius: 3px;
+    color: #444;
+    display: inline-block;
+    font-family: Helvetica, Arial, sans-serif;
+    font-size: 92.308%;
+    font-weight: bold;
+    padding: 4px 13px 3px;
+    -moz-text-shadow: 1px 1px 0 #fff;
+    -webkit-text-shadow: 1px 1px 0 #fff;
+    text-shadow: 1px 1px 0 #fff;
+    white-space: nowrap;
+
+    background: #EFEFEF; /* old browsers */
+    background: -moz-linear-gradient(top, #f5f5f5 0%, #efefef 50%, #e5e5e5 51%, #dfdfdf 100%); /* firefox */
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f5f5f5), color-stop(50%,#efefef), color-stop(51%,#e5e5e5), color-stop(100%,#dfdfdf)); /* webkit */
+    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#f5f5f5', endColorstr='#dfdfdf',GradientType=0 ); /* ie */
+}
+
+.button:hover {
+    border-color: #466899;
+    color: #fff;
+    text-decoration: none;
+    -moz-text-shadow: 1px 1px 0 #222;
+    -webkit-text-shadow: 1px 1px 0 #222;
+    text-shadow: 1px 1px 0 #222;
+
+    background: #6396D8; /* old browsers */
+    background: -moz-linear-gradient(top, #6396D8 0%, #5A83BC 50%, #547AB7 51%, #466899 100%); /* firefox */
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#6396D8), color-stop(50%,#5A83BC), color-stop(51%,#547AB7), color-stop(100%,#466899)); /* webkit */
+    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#6396D8', endColorstr='#466899',GradientType=0 ); /* ie */
+}
+
+.newwindow { text-align: center; }
+
+.header .version em {
+    display: block;
+    text-align: right;
+}
+
+
+#classdocs .item {
+    border-bottom: 1px solid #466899;
+    margin: 1em 0;
+    padding: 1.5em;
+}
+
+#classdocs .item .params p,
+    #classdocs .item .returns p,{
+    display: inline;
+}
+
+#classdocs .item em code, #classdocs .item em.comment {
+    color: green;
+}
+
+#classdocs .item em.comment a {
+    color: green;
+    text-decoration: underline;
+}
+
+#classdocs .foundat {
+    font-size: 11px;
+    font-style: normal;
+}
+
+.attrs .emits {
+    margin-left: 2em;
+    padding: .5em;
+    border-left: 1px dashed #ccc;
+}
+
+abbr {
+    border-bottom: 1px dashed #ccc;
+    font-size: 80%;
+    cursor: help;
+}
+
+.prettyprint li.L0, 
+.prettyprint li.L1, 
+.prettyprint li.L2, 
+.prettyprint li.L3, 
+.prettyprint li.L5, 
+.prettyprint li.L6, 
+.prettyprint li.L7, 
+.prettyprint li.L8 {
+    list-style: decimal;
+}
+
+ul li p {
+    margin-top: 0;
+}
+
+.method .name {
+    font-size: 110%;
+}
+
+.apidocs .methods .extends .method,
+.apidocs .properties .extends .property,
+.apidocs .attrs .extends .attr,
+.apidocs .events .extends .event {
+    font-weight: bold;
+}
+
+.apidocs .methods .extends .inherited,
+.apidocs .properties .extends .inherited,
+.apidocs .attrs .extends .inherited,
+.apidocs .events .extends .inherited {
+    font-weight: normal;
+}
+
+#hd {
+    background: whiteSmoke;
+    background: -moz-linear-gradient(top,#DCDBD9 0,#F6F5F3 100%);
+    background: -webkit-gradient(linear,left top,left bottom,color-stop(0%,#DCDBD9),color-stop(100%,#F6F5F3));
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#dcdbd9',endColorstr='#F6F5F3',GradientType=0);
+    border-bottom: 1px solid #DFDFDF;
+    padding: 0 15px 1px 20px;
+    margin-bottom: 15px;
+}
+
+#hd img {
+    margin-right: 10px;
+    vertical-align: middle;
+}
+
+
+/* -- API Docs CSS ---------------------------------------------------------- */
+
+/*
+This file is organized so that more generic styles are nearer the top, and more
+specific styles are nearer the bottom of the file. This allows us to take full
+advantage of the cascade to avoid redundant style rules. Please respect this
+convention when making changes.
+*/
+
+/* -- Generic TabView styles ------------------------------------------------ */
+
+/*
+These styles apply to all API doc tabviews. To change styles only for a
+specific tabview, see the other sections below.
+*/
+
+.yui3-js-enabled .apidocs .tabview {
+    visibility: hidden; /* Hide until the TabView finishes rendering. */
+    _visibility: visible;
+}
+
+.apidocs .tabview.yui3-tabview-content { visibility: visible; }
+.apidocs .tabview .yui3-tabview-panel { background: #fff; }
+
+/* -- Generic Content Styles ------------------------------------------------ */
+
+/* Headings */
+h2, h3, h4, h5, h6 {
+    border: none;
+    color: #30418C;
+    font-weight: bold;
+    text-decoration: none;
+}
+
+.link-docs {
+    float: right;
+    font-size: 15px;
+    margin: 4px 4px 6px;
+    padding: 6px 30px 5px;
+}
+
+.apidocs { zoom: 1; }
+
+/* Generic box styles. */
+.apidocs .box {
+    border: 1px solid;
+    border-radius: 3px;
+    margin: 1em 0;
+    padding: 0 1em;
+}
+
+/* A flag is a compact, capsule-like indicator of some kind. It's used to
+   indicate private and protected items, item return types, etc. in an
+   attractive and unobtrusive way. */
+.apidocs .flag {
+    background: #bababa;
+    border-radius: 3px;
+    color: #fff;
+    font-size: 11px;
+    margin: 0 0.5em;
+    padding: 2px 4px 1px;
+}
+
+/* Class/module metadata such as "Uses", "Extends", "Defined in", etc. */
+.apidocs .meta {
+    background: #f9f9f9;
+    border-color: #efefef;
+    color: #555;
+    font-size: 11px;
+    padding: 3px 6px;
+}
+
+.apidocs .meta p { margin: 0; }
+
+/* Deprecation warning. */
+.apidocs .box.deprecated,
+.apidocs .flag.deprecated {
+    background: #fdac9f;
+    border: 1px solid #fd7775;
+}
+
+.apidocs .box.deprecated p { margin: 0.5em 0; }
+.apidocs .flag.deprecated { color: #333; }
+
+/* Module/Class intro description. */
+.apidocs .intro {
+    background: #f0f1f8;
+    border-color: #d4d8eb;
+}
+
+/* Loading spinners. */
+#bd.loading .apidocs,
+#api-list.loading .yui3-tabview-panel {
+    background: #fff url(../img/spinner.gif) no-repeat center 70px;
+    min-height: 150px;
+}
+
+#bd.loading .apidocs .content,
+#api-list.loading .yui3-tabview-panel .apis {
+    display: none;
+}
+
+.apidocs .no-visible-items { color: #666; }
+
+/* Generic inline list. */
+.apidocs ul.inline {
+    display: inline;
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+.apidocs ul.inline li { display: inline; }
+
+/* Comma-separated list. */
+.apidocs ul.commas li:after { content: ','; }
+.apidocs ul.commas li:last-child:after { content: ''; }
+
+/* Keyboard shortcuts. */
+kbd .cmd { font-family: Monaco, Helvetica; }
+
+/* -- Generic Access Level styles ------------------------------------------- */
+.apidocs .item.protected,
+.apidocs .item.private,
+.apidocs .index-item.protected,
+.apidocs .index-item.deprecated,
+.apidocs .index-item.private {
+    display: none;
+}
+
+.show-deprecated .item.deprecated,
+.show-deprecated .index-item.deprecated,
+.show-protected .item.protected,
+.show-protected .index-item.protected,
+.show-private .item.private,
+.show-private .index-item.private {
+    display: block;
+}
+
+.hide-inherited .item.inherited,
+.hide-inherited .index-item.inherited {
+    display: none;
+}
+
+/* -- Generic Item Index styles --------------------------------------------- */
+.apidocs .index { margin: 1.5em 0 3em; }
+
+.apidocs .index h3 {
+    border-bottom: 1px solid #efefef;
+    color: #333;
+    font-size: 13px;
+    margin: 2em 0 0.6em;
+    padding-bottom: 2px;
+}
+
+.apidocs .index .no-visible-items { margin-top: 2em; }
+
+.apidocs .index-list {
+    border-color: #efefef;
+    font-size: 12px;
+    list-style: none;
+    margin: 0;
+    padding: 0;
+    -moz-column-count: 4;
+    -moz-column-gap: 10px;
+    -moz-column-width: 170px;
+    -ms-column-count: 4;
+    -ms-column-gap: 10px;
+    -ms-column-width: 170px;
+    -o-column-count: 4;
+    -o-column-gap: 10px;
+    -o-column-width: 170px;
+    -webkit-column-count: 4;
+    -webkit-column-gap: 10px;
+    -webkit-column-width: 170px;
+    column-count: 4;
+    column-gap: 10px;
+    column-width: 170px;
+}
+
+.apidocs .no-columns .index-list {
+    -moz-column-count: 1;
+    -ms-column-count: 1;
+    -o-column-count: 1;
+    -webkit-column-count: 1;
+    column-count: 1;
+}
+
+.apidocs .index-item { white-space: nowrap; }
+
+.apidocs .index-item .flag {
+    background: none;
+    border: none;
+    color: #afafaf;
+    display: inline;
+    margin: 0 0 0 0.2em;
+    padding: 0;
+}
+
+/* -- Generic API item styles ----------------------------------------------- */
+.apidocs .args {
+    display: inline;
+    margin: 0 0.5em;
+}
+
+.apidocs .flag.chainable { background: #46ca3b; }
+.apidocs .flag.protected { background: #9b86fc; }
+.apidocs .flag.private { background: #fd6b1b; }
+.apidocs .flag.async { background: #356de4; }
+.apidocs .flag.required { background: #e60923; }
+
+.apidocs .item {
+    border-bottom: 1px solid #efefef;
+    margin: 1.5em 0 2em;
+    padding-bottom: 2em;
+}
+
+.apidocs .item h4,
+.apidocs .item h5,
+.apidocs .item h6 {
+    color: #333;
+    font-family: inherit;
+    font-size: 100%;
+}
+
+.apidocs .item .description p,
+.apidocs .item pre.code {
+    margin: 1em 0 0;
+}
+
+.apidocs .item .meta {
+    background: none;
+    border: none;
+    padding: 0;
+}
+
+.apidocs .item .name {
+    display: inline;
+    font-size: 14px;
+}
+
+.apidocs .item .type,
+.apidocs .item .type a,
+.apidocs .returns-inline {
+    color: #555;
+}
+
+.apidocs .item .type,
+.apidocs .returns-inline {
+    font-size: 11px;
+    margin: 0 0 0 0;
+}
+
+.apidocs .item .type a { border-bottom: 1px dotted #afafaf; }
+.apidocs .item .type a:hover { border: none; }
+
+/* -- Item Parameter List --------------------------------------------------- */
+.apidocs .params-list {
+    list-style: square;
+    margin: 1em 0 0 2em;
+    padding: 0;
+}
+
+.apidocs .param { margin-bottom: 1em; }
+
+.apidocs .param .type,
+.apidocs .param .type a {
+    color: #666;
+}
+
+.apidocs .param .type {
+    margin: 0 0 0 0.5em;
+    *margin-left: 0.5em;
+}
+
+.apidocs .param-name { font-weight: bold; }
+
+/* -- Item "Emits" block ---------------------------------------------------- */
+.apidocs .item .emits {
+    background: #f9f9f9;
+    border-color: #eaeaea;
+}
+
+/* -- Item "Returns" block -------------------------------------------------- */
+.apidocs .item .returns .type,
+.apidocs .item .returns .type a {
+    font-size: 100%;
+    margin: 0;
+}
+
+/* -- Class Constructor block ----------------------------------------------- */
+.apidocs .constructor .item {
+    border: none;
+    padding-bottom: 0;
+}
+
+/* -- File Source View ------------------------------------------------------ */
+.apidocs .file pre.code,
+#doc .apidocs .file pre.prettyprint {
+    background: inherit;
+    border: none;
+    overflow: visible;
+    padding: 0;
+}
+
+.apidocs .L0,
+.apidocs .L1,
+.apidocs .L2,
+.apidocs .L3,
+.apidocs .L4,
+.apidocs .L5,
+.apidocs .L6,
+.apidocs .L7,
+.apidocs .L8,
+.apidocs .L9 {
+    background: inherit;
+}
+
+/* -- Submodule List -------------------------------------------------------- */
+.apidocs .module-submodule-description {
+    font-size: 12px;
+    margin: 0.3em 0 1em;
+}
+
+.apidocs .module-submodule-description p:first-child { margin-top: 0; }
+
+/* -- Sidebar TabView ------------------------------------------------------- */
+#api-tabview { margin-top: 0.6em; }
+
+#api-tabview-filter,
+#api-tabview-panel {
+    border: 1px solid #dfdfdf;
+}
+
+#api-tabview-filter {
+    border-bottom: none;
+    border-top: none;
+    padding: 0.6em 10px 0 10px;
+}
+
+#api-tabview-panel { border-top: none; }
+#api-filter { width: 97%; }
+
+/* -- Content TabView ------------------------------------------------------- */
+#classdocs .yui3-tabview-panel { border: none; }
+
+/* -- Source File Contents -------------------------------------------------- */
+.prettyprint li.L0,
+.prettyprint li.L1,
+.prettyprint li.L2,
+.prettyprint li.L3,
+.prettyprint li.L5,
+.prettyprint li.L6,
+.prettyprint li.L7,
+.prettyprint li.L8 {
+    list-style: decimal;
+}
+
+/* -- API options ----------------------------------------------------------- */
+#api-options {
+    font-size: 11px;
+    margin-top: 2.2em;
+    position: absolute;
+    right: 1.5em;
+}
+
+/*#api-options label { margin-right: 0.6em; }*/
+
+/* -- API list -------------------------------------------------------------- */
+#api-list {
+    margin-top: 1.5em;
+    *zoom: 1;
+}
+
+.apis {
+    font-size: 12px;
+    line-height: 1.4;
+    list-style: none;
+    margin: 0;
+    padding: 0.5em 0 0.5em 0.4em;
+}
+
+.apis a {
+    border: 1px solid transparent;
+    display: block;
+    margin: 0 0 0 -4px;
+    padding: 1px 4px 0;
+    text-decoration: none;
+    _border: none;
+    _display: inline;
+}
+
+.apis a:hover,
+.apis a:focus {
+    background: #E8EDFC;
+    background: -moz-linear-gradient(top, #e8edfc 0%, #becef7 100%);
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#E8EDFC), color-stop(100%,#BECEF7));
+    border-color: #AAC0FA;
+    border-radius: 3px;
+    color: #333;
+    outline: none;
+}
+
+.api-list-item a:hover,
+.api-list-item a:focus {
+    font-weight: bold;
+    text-shadow: 1px 1px 1px #fff;
+}
+
+.apis .message { color: #888; }
+.apis .result a { padding: 3px 5px 2px; }
+
+.apis .result .type {
+    right: 4px;
+    top: 7px;
+}
+
+.api-list-item .yui3-highlight {
+    font-weight: bold;
+}
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/favicon.png b/plugins/dali-script-v8/docs/dali-theme/assets/favicon.png
new file mode 100644
index 0000000000000000000000000000000000000000..5a95ddab6ff6735b52596ecea54f2b68298cae91
GIT binary patch
literal 740
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
z
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

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/img/focus-manager.png b/plugins/dali-script-v8/docs/dali-theme/assets/img/focus-manager.png
new file mode 100644
index 0000000000000000000000000000000000000000..8320dd915412da48589532736a0c4cfee19479cf
GIT binary patch
literal 209774
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
KpUXO@geCxC8!3|j

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/img/fragment-shader-color.png b/plugins/dali-script-v8/docs/dali-theme/assets/img/fragment-shader-color.png
new file mode 100644
index 0000000000000000000000000000000000000000..2e38b247774ff72abe45051f4e5b7eebe07e03d3
GIT binary patch
literal 194229
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
(ow70KA}und#_a}U+von>*3
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
R#MuA<002ovPDHLkV1m|6XygC@

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/img/fragment-shader-reveal.png b/plugins/dali-script-v8/docs/dali-theme/assets/img/fragment-shader-reveal.png
new file mode 100644
index 0000000000000000000000000000000000000000..8855ba6185fa4aef19ed84b93ab26316c0231a7f
GIT binary patch
literal 164631
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
G8%k74aB
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
vm|f>g8kfSQU+z}!j5o85|LG

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/img/keyframe-animation.png b/plugins/dali-script-v8/docs/dali-theme/assets/img/keyframe-animation.png
new file mode 100644
index 0000000000000000000000000000000000000000..37c3ebc27706c57e938f5e144ee44694bef8fa95
GIT binary patch
literal 7634
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
bD~(m)8}a;~`xhntp#KbXO(Eqv&X4{Fm@Cx{

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/img/shader-animation.png b/plugins/dali-script-v8/docs/dali-theme/assets/img/shader-animation.png
new file mode 100644
index 0000000000000000000000000000000000000000..0512a013a4244e67240e66049460bdb2666d860f
GIT binary patch
literal 178102
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­-X+d98_b1NA8}oKE_&tk+_O
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
e~Ynn$<_%?{;6nu7V%D_7)
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�`!$4oW
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%0Af_C0?o)2khD~f*Xn#0lzs?r>OwM)%(|`
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

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/img/stage.png b/plugins/dali-script-v8/docs/dali-theme/assets/img/stage.png
new file mode 100644
index 0000000000000000000000000000000000000000..67e0dc5c2fed93dcd7bf141832d79e57f408bd9e
GIT binary patch
literal 8346
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.#MY?RzDq=5U20&Hd^XsS!g<)n<;0G_mMXB%Htt
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
-(1`A7(%B53b86r(c2Cm(yqpEbSUG4JAO%bTG
zkwFdvs9~~)%gtUh+YsC3Y4NJeCA2xH{Jsm
zw&7LR!#!ULr%pu%2+|sDXKYOi-uJ%1`#uh1iG1_D;Hng%>mme~5M7WX05gNt7sl2E
zHnyQC9lb#!K-6C7B(gs*!?9;76v>_UkUR7>HN$&F=9*d~YDbh33Zarf
zoGL9N!f=Sx17xX>6&1Zgl8Gxud`Ns>ks^(VnwCb!c-Ih`33O8|2vRMfWgi)wrtF_)
zQk`NatgtaHnYJy#cIk>C(E?@L!@?-h8z^bV6;*MC>z6Nc{o*czBH-c@J3;YPfk*)%
z%P16rQv{!IbsCdKR#P!A-f@snd$7Kk)~kLTM1Ps`ec#0UFMJifwb%2a@IemW{35P=
zc85~0(naNuJ}!LqE5RnPv>*(p#w%}vtGh}yHGc7rg@623g~GFYdBTz9XIbs0>`0A>
z(UcBliNFrJuTc|#ZJ^Fwzbib!b;BJ#)?Yp-WS?KhGHGF#)O_&@7CK~Ohc-@#Ic(Np
zbh+f5WEn@BB?Uz;SZ6iD46!wPKE!=kPnicM%w!6CiJ@^;P1KIg38lLHzYEbBQBojM
zlmgKXr;a7R%W8Q6Vq(k>a`$-LdCCP(G{k3I#T{5U*tK5}CroIR6X
zOqd&j9Ij1LJ7@6L4X2J!{D{0Plql
zf82O!DM&{q+RUcf`JK_^53)SjPSMXouWe|n2|h02CXwNEi_uh&wb!$9)0eR^9dK=9
zNVB`cWcMo5rlT3R9M_L=X7y>JDXms?Q{mWkFHc5yS5TQ_nggN!CN{|VSDq{#t2Ojm
zr4>hq;zLBKh^5EY78#s5&EcyP%1b4q-5tieEp3=ksH3V1ym$0B#_+@@BkQ5Z7MPA3
z+VwHI8PV~W(Cud5dz@c@{mEW?BjTiwRe>s-el(kVeAeC03f9@^z{KX=+nFKFTiP%!
zhI2W(t?Cy%kNt#0+Lo$sO
zp5Ez`Y%e)J)~r!CffM=|OAe;7Kw^m#p>++{#_;+tbNozUeBh&sSK-7>j#JkwhmOMG
zMWMHl^qmEUMMv9#>!6KFJ532$U7OJ#3RRIzS!T(hADq!e$ztu9Ml#*(iwnkd-SNBc
zRh}4Sr~k0z+%1u%LNVuQH8M6yI$*EN69-6;;JPnd-Y|aePaKbL8{c-f@-=rS)}4-0
zIEF71dh5Eiz&CvxT>L-b&p!z_opikJMM_b~o?Kxz?wNIti{$FxnZR!FloDB7AWI4i
z7bOR4?;U<-VHq)>V!cb?V{b+^KX#`*Q)n`vIZGi3IHPllS~{q>py_?_%Fr6>dV#7}
z#a#
z+%Qs9;H(>=G3jLw*1`HBTCe;GLG5>tKmBUn|Jj=UYrdVkinlX3dNc9THf`*9)60#I
zJOr=46aMG{$5);cx;FCj9}<4z&BC{T6`bF8+`446Q_uJR`36dIXa5H?vC>Q<+vd@C;(U%MA9#@I>+Xh611~(dKC{QmxZNvC2Q4sd(T!~aEpe`R
zP0g7$R}>vH-RsOple+1$Pe(foLGaJ3IcDU8SvPh+zaAVlZg~L_m!1hC>G^NjIOW}3
z!q!Sh9oAX07O@Ugn2aOGE4Xl_raIy1TH)%*^VkLDzK<#&`7G=JeT%;COc<ydIAiqiQ2!9_?95xWXeV
zH*qN*=ArR20oGC=wj8Hi(Ik;5HH_>}&6a
z$A1?-cptpzW;oI}x@m&Dp+++c$jG4+BEoR!*p89IbwY$hgs6!)Atnjc6;r{M41lR~
z-bg}t87b~H=~Pmo9GUA;5(gQDE{_1ECFl;7R~!XxQ)7cgtPRA$l-jN0s+t`yh%}U~
zGKoqf%g{fKua{X^KFQ+Rty~F?B32Z=HMU1W=Y-v6LT6)|?Hwl59kgo@ZBS`x%n{lO
zQKi*D)lOOC8ICPK%gW*;Q8COhl^%r(jf~N_%;MrPN)K)5(tY3xgbsBcQK1x%({!N0
zTMpN-gNNq9`l4H}{%3-dKVbacui^fWII1^(H>X$r1I_xgsI4=N#@#PcLJRlYZ2ao`
zjBmad{^=Xw{6*oW%J^U20dIS&a_>3M&%SMhAKb^UZhk$nR20wT^)EsHY-a9C9);Ne
zWCx=LA|3J@e*|~m&2|eb2bU&)9>chU&cL^+K&_`Ox-%hU{(#QIfA@p}e%^_lO=SH%
zxk}gzL(qJj*L@vZ+xJ6rcUE(ORME#)58+)wl$1zhR?N|&sovByevd81a0llatSt#$
zq^jY_DdWTU4Y^^V;K5G@KKYr*qeEjII0?M*knrM{31@BrZ3O9(XT&t?RLyw!IpKp3
z!&lw~{e_gS6?6Jl0xJo>{GjkZo=s7+bkJWgj`ZQm)zq|!3SCT1quq%xB64(b7C?|C
z8Ip?HDCyZ*$2{-uUym$aPdPYBb@Y0cR$f4P{CXCTt+Ep#j^M(RL%PwBE9;lh;27_$
zv%K>OR`o#^2cr~fSvX=WnRXpFz5MGlJXdkv(}qBd9bft{2mfu-0)VxJMHV-Axu_si
zsa1{8xq@b4k#1oDR+gy3QF>me!)10hz}iUJFOg-BcOA|)X|J`kmy{UC=+;$+8&A`1
zUSXki2t7K+lq51hU-pVqoofZMK`D>$o$Ynrl5;M#!i&tPwH$UJmUXb%m93d#pb?^Z
z;?X12cicjGg+9bzt-oXA?r)cVEy#7^=>E+#7nWq}jL
zE41AT&*_cqc6W1H7P*B-Sz$YM5w*Z9GG;_Kai}OIk#^TZbi}qGqBPbbtw$V8#PCx=
zyl3%nBy>r5T^AA8Wy4ZXc6Ws)E4ekK@j-)8$4H4|f+lQ-LDh$E{Tgt!r(BGzmGJlz
z@Ue&B*&X57apUV>4J!ko8>LjOC=N_0>&U2uk39;50`7f{vEpENLsEHNW#y6@;uAQ!
zoeDRd7H(Kp&TkqQH(>1~DW^IkwA?HcJDc_##>P&PPpmA#Vwum*9>h{%J(r;fn3ws@
zUpUDox4eJyjaf<3)mk=ui4}++AmYG^eBCXb@V(-TK7|hG+bSA+Sh+y8b|XcxM&tUp
zr4_2WqE{TDs7})&usYyc@C=_hPqYqp0_#^Vu)BScx~!-viKA_>5zQzvZ3}`ngfK-K
zqt{+yseY0pgNrQp0!|{qQtFF0L#0FffO0Ij{xa3V(HuY$F^i~IphPt0j&qXj#Hlw#SydQr0
zUS;iMa+Uw;05{R`WP-rwVyY$~3`ZzS
zz}7?eBOQF=8r*wuS@P!+jAN3g|Ihtz_ODF;?FTgb93FVyJU_5mZjslAX#4d5PQ7qNDVY+s}vJ;B=O6I9_mWeMFBq;!wd1;hEv=-$0duK+-AYVw
zcu6K1we-eE-3y_UoK7^)JeG7M31;&fVJ5&%?eGMZ*QGVe+s;s)y9G`jV|;X(qAU>c
zNRf*!%{X3{BIim1i^jvZYl>KUS2qvbF+>&H1N
z=TR4FV@(l?1VfgVsd$2g^oo3PzDMsVOUG_b3|l-T3|-{PPlmf;n5A_ne&cwCsG=i
zW}$RZ>_fWcuJ6??M^NL$S_*)erK?zmJkRo=ZI;@WM?QrL>hmZir&>9MkUyoo8a{y4
zi`eQ*ki{GDi>vgO*6_X{=pwzP73!4&A8V?54Ov*g`AC211P-CELhA=~SGQ@~7U|bq
zd*%tc%aL}};9a2W8pc~YjM_2Hc!-u2O>2ZWp^3_P1WmI`#bpjPS6Si`gM~}mCgMaZDe$B)50Zf52kT&cv94GA
zb5B{m8{Y9I9(mU$=ic&z9KZ2?u0HTvw43+yZ(a+VLwL!_z{_tD$|%ICo=ZQ)ql-<$M2oHhr;2q+D(!LuA2
z4SBd&JSb%Mbz~=+^r69^ibjk9HyY0biTjwZlI3IrJS7!|%U#Y;WC4d)r5y_c;7tg7aOXg__slnr%asSi8D{7k~ew>3YYdxJ4+`iO^sEYl+?7exg
zX4_fb_j}h`d+%>NW1k*x-+8`Q5?mx9=>lSqWfde$DNN#2fY?M3444=SJC0oyoK$R#
ziy?7L*(SsU7Y1Xd03l|U00|)?KqF|lx>NV<@r>WJ_gd?H^T*m>_jOECGKBn*+pFqU
zcUAX2=k)jOZ|`?_p5Jr$33NGw;R|%nfg7CWWbYA{^#;0_)1JJ5T)%?MFSEV6jI@{V
zvLHE7GragxgXD@8kqZy~2Ux4bt|P`3EuPe_h&umwzGnU{5yJWDfYT>S=AB0?@O@@k
z>paWpfZ3@b^;HP-$f#dh^TM;L+w{oxr70jc{)7V_dTO3mZ367bP=bpF>rk15dPIK2p{+zW41_i
zSqg^42ON=88#PaVcEz86W6kNU6ZFW?7KUDl30i~38z}?#jRTE@dcXEMU)Y%TqAx!s!!wUO@=i@x5=VAB*={Ue8zHhj7yPu
zcb&z_KFd~Fo*Xl58j?m1=LcjOnr54n5^Z}z*Pc+Po19u*rfHvJD2KQ(Cxl4l!ICTb
zXQXI}rI-gy1#v>wj)ev$lQWElQ(U4Xxri&6Im<mU==m)*keoIB^0dtSPB
ziEi@QoIm{Ex%%_ZGWzQ8V={S+^v?f^bohQY#;GJ58LYZuKD}>S_)q><$B%wR=D+(Z
z!cYE;@cln@z}vpN!7g3FT{u^aM`w3$aY?J*&7r`wc-2{wSukVx!H=;28Lz`W0P?Ck
z?@1p#NZUUPEN7A>tZfT#wI|MGgb|*GJ*M2xfDwtCtaz3cvs(cO>tZ&)Y~otdM{fu2
zygV>yEpaRcu$t=PdGfHqvZ2oP%zH;v?f+h3;54eZ@rXtJAp5Hiu$d2OQy{yV!=7Pe0*jjKpqLYBsCR=(fB3lhraQg0!^%Ja2T_^LNJwswqPeh0jF4&Sl|!(58a
zr5aao+`9*HsYL?mOCdWmI2THplch*5y%`_Ec*`S@I&j|lA(!+4RQ<_Cx+j{jqfa0_
z#|noFLN>?pqXTlii(4(owWCf;oX*jdNUl(cq$)L85+f+AEHR4{UjM`wvzpJC&F2V-
z<0u53QB8(_`a<@RNyX*iiW^JMeyGXSia;b)HS?z7aBE1|p5R{EC(k2(ToX
zlxPuo8+g+qQtm;)l^J3gmovHR=;p_)G~vAA)Z_dR=b$r3bVIt~d5*%63xf^L`wvl7
zGfWgT6pmbLV5Q45Z|E{2!86@*{QCPcKlsm;Yd7HDUC--Zo7vtrLWcP&vwv*-;WI0K
zB@{^Xdq|Ah$;k6LaXM-WFqX#}!5YJn8`e{Wr;m0pZm;fY7!zKa55BM?ZfVKb%f
zLC_sVpX;1Mb3r_HsYlk-!fIhuBK_*6&;Ya#E}#z`-rOi3zWL&1D-0=UD09~HUrQA4
zVhPs{lqSHbUBC-Dmq3R#{`VHyLVCSWpS-f(oV#A4puHp0Qu+C!K^+9N!%m*Vj-Mrq
z!&wcXrmM%O8X{v{-4F)5Xmgrs;}l`*UfM8)W`GV)<4n=n3G?=tN|eTgRd>Mrpu+{B
znZE$7GH8}`%Nx|oYczSEAcwfTER>KSC3P%&x-OTnhEOO2RW?jLj;gmVIIPP=KVfU<
z9JL?ex>)2BDwxF*BPiuxUJQX5(~|aOn#q#yJT&i|SM+(?_g>%^zws~e%zJ)|fqsNb
z|I62N>P_E-8{AFc1H|lj`@4-Fcv|s8$6xzUOm{b|##7<3Idzc=bn(ulZ|B
ze)zk-n{PPy`xru0*m>%!x$(aLnYF8PecQT>HcK^U}dJmMow=$^Q)!!OH^?h$LdeUy;8;^(&q^!}MBNF|LDiejEg0JuK9AM@O}b?y>oJF^)Op*dJb(T>FaGHZ
zS%CZY8eY0&>?cpIJH#B$*R1LRhZ`G&iy42oz<=a2!)ptcvnBapL9@L{GpLCvlb1$U
z2a;Eox?-6+Qq1INtP-qnBui)#vU8|pQjfBzlAx-^z|_a7T0ePR2OgxCg&v4mG4r^B
znQ};()H+YtK20qK2^#L^
zhOcZTE^fUVFZ_J#6TdQ!jLVMLF3DYl*r72IT`r^pSt8W9EF1u{dcaZLu&Q@h)DLlL
zc$1C6A&pxRy37ztk{Xcl$RIPFX5Rh#%6I)BY^T7t{bz~SJShyD8docMr9@K(9PC7OV$pb%P=W;FICDw~m2osLGeI8;x~fFh
z7DZc1GnYa*XJ#OqCZH_yLVfF&a{{ffpgq7lcaadb!FZwJb2|Wk*%d
z$r|v7GbTBaeJ=m?1-pu)Q!OcHz576rvg+xR$x1Wj5Vs;Gp-T=wILq$VJp@f;P2^jq
z#~wzOVgc3klMPhMS}eCDOLv}_cg`#Ry!9WR=V!j*f8xq-e=YC~H{bEM7==jA6;6zQ
z`i4vp&=vf>r%OP>Km85iKmDx0#c^V`uRQ*+t2=X((~K6F!f-JQ3iUu9F=_}Pe*jb0Z5f~TTlNJiLXn}@mh^lRC9
z^#kO?n;c(z7I#q8vP$fyrSh`E^fs~Jw!C0%^y-Vaes1d+P@j4jJ-0{3lf6UD5MN=b
z!@S|u$bG7*)PdkVsvCSXKF+Q@!)7`lXCuXki6bqG**crhB21^k#}DA0zoX1no{MJ!
zZ+zG=i&Sc?6lxX5fXv~421ch2E*F)TaakDh}EC?Q3a^mKj|d}X`{oY?`Ez5GEE
z@A`=2>D~ZeVrZo>*{y6Z)%OIcK0dcJ4+XuItY9522h?Q(T4anG%X??^vOgo}`WYs~
z?2v36rva~f;0stBKF?|;oWw{P*X-`>k_UgXR_>22WbYl+yfjMOSY@uJsu->;;;M?p
z#ukU_$n!b#g9EmnJ7PFDf}SuxS#abN)+x3)VmUkF=FOYTXG^+erj40Q1WBZriDEcc
z%sA^p!;+AD{#um&GIJ#|77+;jnm~&4+Iu0HgHZ5al8uyLSr2eK+e{yNh~dNc<1UYD+>)-xOEt?1Sq!*TZ*UkUOzSD9M*Hjxj+putJA*?)%1GxSHH-!=bB+A?Pa7vk
z72oo0Q{MWfIm>HGJ6CL$iNRPX#MX1>wDEQSxw8M=#xH&_@iXt);Hy5TBdk`;%*Yj(
zHFPRu8Kc#hXBU}we|*6~J7TeNTvf-LFTikhz=#=*6LMWHRM#^~la)38?hf3$2bW%i
z<-+4m<-*)GR|pRxm=%PWlR(T$%);gdYzCMug*H`;s}3KFj??G)^zgB{(&J
z&2cG~?PUxVw??z|yXJOI%tM&R?&683+(TW5BdRq+`=EQ3Q)ckGm3RYQbEY*i^a1DJHLYUr=*d
ztw>~g=(ptl#*#sELPIHfSE*)m=W#YS@5V`4T&9#jm82lr7HyMrJ#oSyCp34&v?Se`
z$lf`34gg>BkIwV+U;Dkh_`Yu@>70&0?aF5-X2XUct@8KY<@t`!OMKIt9l!c+<@BEu
z#v?~}pq$?hh$Y@Sct1a}`ZRpbhz2~brsfZzFO=pObCfUqtgqyqzxf>;@gh~X;CDF=|FR6_}swS6ZQYVEDq@JX3sQ2*#k1*z4BsD@O
zbW)1I5-j9sD)^NT!VkV9XN^@vR!fAkYb4@|N=YNY_goE8%0;
zjK}YT9Lt8&dTi!w1)CVo9Oe|KC6(?sPK>X64dkxiGH>zNm4b`Z!dfq3sX|CbD?;!}
z1$3(T9C5CgqAeF$V9vKwR;|}K3$FjSfHTL|sm~-`dWqvMauQo?bBl9l&Otq<%YQN?
z)yQ)`&UnxErzsJhq)C?r^IoC*pT+(9`o*qCG)kaN>G5Pg(Ul7m9WzIK&Aiii$7P
z1BK3nsu?jnbB^kf2N^za5ANJH^HWpe#t1JCazrE)$6;Q_%=LQ9P@F)S0zb|M=1XBM
zVx{=egyl?ZJ4mU-)#gO&Iz%#EhRPJAErpJYIH{1N>}$o5PMCPdNgFtBCtUY)Hb)C~
z>V3BB8B>3P_btr;-t&9H`=2#F^HI-JPb`_=%q&h);lZhg&KOmSN#@`h?Cb@;{7aPg
z{=>vC{n{~~{pl4K#~zzG7Gax(PU%9!LdVQw!_93^{Y1^sYJzj5QRW%9;`De%ovtul
z-k^4if-wn2pXvL%&7g+u(}Fz*hbNibo2ZmTr9B446s;)JcN22X41(j7S1v_3Sit6~
z(k()-@mw?X5ROiYzIS5?&7fQ(szw!hJV=k)qIb8_M+mx}Twrx^awdHlW6+h!h*=+)
z&?`)`Wg2ss1v(TjM$+=ZtgU<~qt)f_km!7wKzk*zo{1n=;ck=%3ra;9?`yd#>RZpzNtN1@qZ)<#_J$gv}Lk=Akv
zd2pF5fleW+VJYIY14;NM+<9u=Id@KfzUT)Y=BK{$?{Mkkf15TYnvpB|SZCPM_?y4&
z_`6RlF*>f#Gk2XA{0e3>c<&3s7k!%IPT-A`f6l)SpT-GA_&@kB-cI_SZ=??ZB?1dz
z|Je_5nn##%h2f1WT-kX5{s4H*EB8IH-!J#TU~3+@;?$u{V0`v8JKN`(9W*RiFs5Ow
z0WQs0%1su}-(Yd|Dl3*m^xv4ohJHr{<#_aU=#bryn8RbH2zEaizcz
zUpBJhZxIj5|CV5uNG`Eb$6;u=;x4k|&#=qoQXXr+CbW!Y_}C@K_rF8=oLYGBZdi26
z|Mq<34?Y@r=yip|UYXG$td_#>e!OC59C+|PMHUhB6a$wy<`@^Y%H}im@`y|?CjhES
zY0IjY7GWP_XIg>~f|V^p2|enifVoFkdPlET_;`qabaWo#|
zNjO`wst4%Kn9kozD>cjd8D4t!67}^3^~sE7%p@Y34`{nci!a!ps-n||7#&I`RZGmO
zGAZ&<=Cwj+p}^cnnVdXWK
s5i)p^b?4ZX
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∓7@9BJA>x>gq+F0HaWEsK2h{_h-P+Q~
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

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/index.html b/plugins/dali-script-v8/docs/dali-theme/assets/index.html
new file mode 100644
index 0000000..487fe15
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/index.html
@@ -0,0 +1,10 @@
+
+
+    
+        Redirector
+        
+    
+    
+        Click here to redirect
+    
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/js/api-filter.js b/plugins/dali-script-v8/docs/dali-theme/assets/js/api-filter.js
new file mode 100644
index 0000000..37aefba
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/js/api-filter.js
@@ -0,0 +1,52 @@
+YUI.add('api-filter', function (Y) {
+
+Y.APIFilter = Y.Base.create('apiFilter', Y.Base, [Y.AutoCompleteBase], {
+    // -- Initializer ----------------------------------------------------------
+    initializer: function () {
+        this._bindUIACBase();
+        this._syncUIACBase();
+    },
+    getDisplayName: function(name) {
+
+        Y.each(Y.YUIDoc.meta.allModules, function(i) {
+            if (i.name === name && i.displayName) {
+                name = i.displayName;
+            }
+        });
+
+        return name;
+    }
+
+}, {
+    // -- Attributes -----------------------------------------------------------
+    ATTRS: {
+        resultHighlighter: {
+            value: 'phraseMatch'
+        },
+
+        // May be set to "classes" or "modules".
+        queryType: {
+            value: 'classes'
+        },
+
+        source: {
+            valueFn: function() {
+                var self = this;
+                return function(q) {
+                    var data = Y.YUIDoc.meta[self.get('queryType')],
+                        out = [];
+                    Y.each(data, function(v) {
+                        if (v.toLowerCase().indexOf(q.toLowerCase()) > -1) {
+                            out.push(v);
+                        }
+                    });
+                    return out;
+                };
+            }
+        }
+    }
+});
+
+}, '3.4.0', {requires: [
+    'autocomplete-base', 'autocomplete-highlighters', 'autocomplete-sources'
+]});
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/js/api-list.js b/plugins/dali-script-v8/docs/dali-theme/assets/js/api-list.js
new file mode 100644
index 0000000..88905b5
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/js/api-list.js
@@ -0,0 +1,251 @@
+YUI.add('api-list', function (Y) {
+
+var Lang   = Y.Lang,
+    YArray = Y.Array,
+
+    APIList = Y.namespace('APIList'),
+
+    classesNode    = Y.one('#api-classes'),
+    inputNode      = Y.one('#api-filter'),
+    modulesNode    = Y.one('#api-modules'),
+    tabviewNode    = Y.one('#api-tabview'),
+
+    tabs = APIList.tabs = {},
+
+    filter = APIList.filter = new Y.APIFilter({
+        inputNode : inputNode,
+        maxResults: 1000,
+
+        on: {
+            results: onFilterResults
+        }
+    }),
+
+    search = APIList.search = new Y.APISearch({
+        inputNode : inputNode,
+        maxResults: 100,
+
+        on: {
+            clear  : onSearchClear,
+            results: onSearchResults
+        }
+    }),
+
+    tabview = APIList.tabview = new Y.TabView({
+        srcNode  : tabviewNode,
+        panelNode: '#api-tabview-panel',
+        render   : true,
+
+        on: {
+            selectionChange: onTabSelectionChange
+        }
+    }),
+
+    focusManager = APIList.focusManager = tabviewNode.plug(Y.Plugin.NodeFocusManager, {
+        circular   : true,
+        descendants: '#api-filter, .yui3-tab-panel-selected .api-list-item a, .yui3-tab-panel-selected .result a',
+        keys       : {next: 'down:40', previous: 'down:38'}
+    }).focusManager,
+
+    LIST_ITEM_TEMPLATE =
+        '
  • ' +
+            '{displayName}' +
+        '
    • ';
+
+// -- Init ---------------------------------------------------------------------
+
+// Duckpunch FocusManager's key event handling to prevent it from handling key
+// events when a modifier is pressed.
+Y.before(function (e, activeDescendant) {
+    if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) {
+        return new Y.Do.Prevent();
+    }
+}, focusManager, '_focusPrevious', focusManager);
+
+Y.before(function (e, activeDescendant) {
+    if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) {
+        return new Y.Do.Prevent();
+    }
+}, focusManager, '_focusNext', focusManager);
+
+// Create a mapping of tabs in the tabview so we can refer to them easily later.
+tabview.each(function (tab, index) {
+    var name = tab.get('label').toLowerCase();
+
+    tabs[name] = {
+        index: index,
+        name : name,
+        tab  : tab
+    };
+});
+
+// Switch tabs on Ctrl/Cmd-Left/Right arrows.
+tabviewNode.on('key', onTabSwitchKey, 'down:37,39');
+
+// Focus the filter input when the `/` key is pressed.
+Y.one(Y.config.doc).on('key', onSearchKey, 'down:83');
+
+// Keep the Focus Manager up to date.
+inputNode.on('focus', function () {
+    focusManager.set('activeDescendant', inputNode);
+});
+
+// Update all tabview links to resolved URLs.
+tabview.get('panelNode').all('a').each(function (link) {
+    link.setAttribute('href', link.get('href'));
+});
+
+// -- Private Functions --------------------------------------------------------
+function getFilterResultNode() {
+    return filter.get('queryType') === 'classes' ? classesNode : modulesNode;
+}
+
+// -- Event Handlers -----------------------------------------------------------
+function onFilterResults(e) {
+    var frag         = Y.one(Y.config.doc.createDocumentFragment()),
+        resultNode   = getFilterResultNode(),
+        typePlural   = filter.get('queryType'),
+        typeSingular = typePlural === 'classes' ? 'class' : 'module';
+
+    if (e.results.length) {
+        YArray.each(e.results, function (result) {
+            frag.append(Lang.sub(LIST_ITEM_TEMPLATE, {
+                rootPath    : APIList.rootPath,
+                displayName : filter.getDisplayName(result.highlighted),
+                name        : result.text,
+                typePlural  : typePlural,
+                typeSingular: typeSingular
+            }));
+        });
+    } else {
+        frag.append(
+            '
  • ' +
+                'No ' + typePlural + ' found.' +
+            '
    • '
+        );
+    }
+
+    resultNode.empty(true);
+    resultNode.append(frag);
+
+    focusManager.refresh();
+}
+
+function onSearchClear(e) {
+
+    focusManager.refresh();
+}
+
+function onSearchKey(e) {
+    var target = e.target;
+
+    if (target.test('input,select,textarea')
+            || target.get('isContentEditable')) {
+        return;
+    }
+
+    e.preventDefault();
+
+    inputNode.focus();
+    focusManager.refresh();
+}
+
+function onSearchResults(e) {
+    var frag = Y.one(Y.config.doc.createDocumentFragment());
+
+    if (e.results.length) {
+        YArray.each(e.results, function (result) {
+            frag.append(result.display);
+        });
+    } else {
+        frag.append(
+            '
  • ' +
+                'No results found. Maybe you\'ll have better luck with a ' +
+                'different query?' +
+            '
    • '
+        );
+    }
+
+
+    focusManager.refresh();
+}
+
+function onTabSelectionChange(e) {
+    var tab  = e.newVal,
+        name = tab.get('label').toLowerCase();
+
+    tabs.selected = {
+        index: tab.get('index'),
+        name : name,
+        tab  : tab
+    };
+
+    switch (name) {
+    case 'classes': // fallthru
+    case 'modules':
+        filter.setAttrs({
+            minQueryLength: 0,
+            queryType     : name
+        });
+
+        search.set('minQueryLength', -1);
+
+        // Only send a request if this isn't the initially-selected tab.
+        if (e.prevVal) {
+            filter.sendRequest(filter.get('value'));
+        }
+        break;
+
+    case 'everything':
+        filter.set('minQueryLength', -1);
+        search.set('minQueryLength', 1);
+
+        if (search.get('value')) {
+            search.sendRequest(search.get('value'));
+        } else {
+            inputNode.focus();
+        }
+        break;
+
+    default:
+        // WTF? We shouldn't be here!
+        filter.set('minQueryLength', -1);
+        search.set('minQueryLength', -1);
+    }
+
+    if (focusManager) {
+        setTimeout(function () {
+            focusManager.refresh();
+        }, 1);
+    }
+}
+
+function onTabSwitchKey(e) {
+    var currentTabIndex = tabs.selected.index;
+
+    if (!(e.ctrlKey || e.metaKey)) {
+        return;
+    }
+
+    e.preventDefault();
+
+    switch (e.keyCode) {
+    case 37: // left arrow
+        if (currentTabIndex > 0) {
+            tabview.selectChild(currentTabIndex - 1);
+            inputNode.focus();
+        }
+        break;
+
+    case 39: // right arrow
+        if (currentTabIndex < (Y.Object.size(tabs) - 2)) {
+            tabview.selectChild(currentTabIndex + 1);
+            inputNode.focus();
+        }
+        break;
+    }
+}
+
+}, '3.4.0', {requires: [
+    'api-filter', 'api-search', 'event-key', 'node-focusmanager', 'tabview'
+]});
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/js/api-search.js b/plugins/dali-script-v8/docs/dali-theme/assets/js/api-search.js
new file mode 100644
index 0000000..175f6a6
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/js/api-search.js
@@ -0,0 +1,98 @@
+YUI.add('api-search', function (Y) {
+
+var Lang   = Y.Lang,
+    Node   = Y.Node,
+    YArray = Y.Array;
+
+Y.APISearch = Y.Base.create('apiSearch', Y.Base, [Y.AutoCompleteBase], {
+    // -- Public Properties ----------------------------------------------------
+    RESULT_TEMPLATE:
+        '
  • ' +
+            '' +
+                '
    {name}
    ' +
+                '{resultType}' +
+                '
    {description}
    ' +
+                '{class}' +
+            '    ' +
+        '
    • ',
+
+    // -- Initializer ----------------------------------------------------------
+    initializer: function () {
+        this._bindUIACBase();
+        this._syncUIACBase();
+    },
+
+    // -- Protected Methods ----------------------------------------------------
+    _apiResultFilter: function (query, results) {
+        // Filter components out of the results.
+        return YArray.filter(results, function (result) {
+            return result.raw.resultType === 'component' ? false : result;
+        });
+    },
+
+    _apiResultFormatter: function (query, results) {
+        return YArray.map(results, function (result) {
+            var raw  = Y.merge(result.raw), // create a copy
+                desc = raw.description || '';
+
+            // Convert description to text and truncate it if necessary.
+            desc = Node.create('
    ' + desc + '
    ').get('text');
+
+            if (desc.length > 65) {
+                desc = Y.Escape.html(desc.substr(0, 65)) + ' …';
+            } else {
+                desc = Y.Escape.html(desc);
+            }
+
+            raw['class'] || (raw['class'] = '');
+            raw.description = desc;
+
+            // Use the highlighted result name.
+            raw.name = result.highlighted;
+
+            return Lang.sub(this.RESULT_TEMPLATE, raw);
+        }, this);
+    },
+
+    _apiTextLocator: function (result) {
+        return result.displayName || result.name;
+    }
+}, {
+    // -- Attributes -----------------------------------------------------------
+    ATTRS: {
+        resultFormatter: {
+            valueFn: function () {
+                return this._apiResultFormatter;
+            }
+        },
+
+        resultFilters: {
+            valueFn: function () {
+                return this._apiResultFilter;
+            }
+        },
+
+        resultHighlighter: {
+            value: 'phraseMatch'
+        },
+
+        resultListLocator: {
+            value: 'data.results'
+        },
+
+        resultTextLocator: {
+            valueFn: function () {
+                return this._apiTextLocator;
+            }
+        },
+
+        source: {
+            value: '/api/v1/search?q={query}&count={maxResults}'
+        }
+    }
+});
+
+}, '3.4.0', {requires: [
+    'autocomplete-base', 'autocomplete-highlighters', 'autocomplete-sources',
+    'escape'
+]});
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/js/apidocs.js b/plugins/dali-script-v8/docs/dali-theme/assets/js/apidocs.js
new file mode 100644
index 0000000..e00591c
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/js/apidocs.js
@@ -0,0 +1,370 @@
+YUI().use(
+    'yuidoc-meta',
+    'api-list', 'history-hash', 'node-screen', 'node-style', 'pjax',
+function (Y) {
+
+var win          = Y.config.win,
+    localStorage = win.localStorage,
+
+    bdNode = Y.one('#bd'),
+
+    pjax,
+    defaultRoute,
+
+    classTabView,
+    selectedTab;
+
+// Kill pjax functionality unless serving over HTTP.
+if (!Y.getLocation().protocol.match(/^https?\:/)) {
+    Y.Router.html5 = false;
+}
+
+// Create the default route with middleware which enables syntax highlighting
+// on the loaded content.
+defaultRoute = Y.Pjax.defaultRoute.concat(function (req, res, next) {
+    prettyPrint();
+    bdNode.removeClass('loading');
+
+    next();
+});
+
+pjax = new Y.Pjax({
+    container      : '#docs-main',
+    contentSelector: '#docs-main > .content',
+    linkSelector   : '#bd a',
+    titleSelector  : '#xhr-title',
+
+    navigateOnHash: true,
+    root          : '/',
+    routes        : [
+        // -- / ----------------------------------------------------------------
+        {
+            path     : '/(index.html)?',
+            callbacks: defaultRoute
+        },
+
+        // -- /classes/* -------------------------------------------------------
+        {
+            path     : '/classes/:class.html*',
+            callbacks: [defaultRoute, 'handleClasses']
+        },
+
+        // -- /files/* ---------------------------------------------------------
+        {
+            path     : '/files/*file',
+            callbacks: [defaultRoute, 'handleFiles']
+        },
+
+        // -- /modules/* -------------------------------------------------------
+        {
+            path     : '/modules/:module.html*',
+            callbacks: defaultRoute
+        }
+    ]
+});
+
+// -- Utility Functions --------------------------------------------------------
+
+pjax.checkVisibility = function (tab) {
+    tab || (tab = selectedTab);
+
+    if (!tab) { return; }
+
+    var panelNode = tab.get('panelNode'),
+        visibleItems;
+
+    // If no items are visible in the tab panel due to the current visibility
+    // settings, display a message to that effect.
+    visibleItems = panelNode.all('.item,.index-item').some(function (itemNode) {
+        if (itemNode.getComputedStyle('display') !== 'none') {
+            return true;
+        }
+    });
+
+    panelNode.all('.no-visible-items').remove();
+
+    if (!visibleItems) {
+        if (Y.one('#index .index-item')) {
+            panelNode.append(
+                '
    ' +
+                    '
    ' +
+                    'Some items are not shown due to the current visibility ' +
+                    'settings. Use the checkboxes at the upper right of this ' +
+                    'page to change the visibility settings.' +
+                    '
    ' +
+                '
    '
+            );
+        } else {
+            panelNode.append(
+                '
    ' +
+                    '
    ' +
+                    'This class doesn\'t provide any methods, properties, ' +
+                    'attributes, or events.' +
+                    '
    ' +
+                '
    '
+            );
+        }
+    }
+
+    // Hide index sections without any visible items.
+    Y.all('.index-section').each(function (section) {
+        var items        = 0,
+            visibleItems = 0;
+
+        section.all('.index-item').each(function (itemNode) {
+            items += 1;
+
+            if (itemNode.getComputedStyle('display') !== 'none') {
+                visibleItems += 1;
+            }
+        });
+
+        section.toggleClass('hidden', !visibleItems);
+        section.toggleClass('no-columns', visibleItems < 4);
+    });
+};
+
+pjax.initClassTabView = function () {
+    if (!Y.all('#classdocs .api-class-tab').size()) {
+        return;
+    }
+
+    if (classTabView) {
+        classTabView.destroy();
+        selectedTab = null;
+    }
+
+    classTabView = new Y.TabView({
+        srcNode: '#classdocs',
+
+        on: {
+            selectionChange: pjax.onTabSelectionChange
+        }
+    });
+
+    pjax.updateTabState();
+    classTabView.render();
+};
+
+pjax.initLineNumbers = function () {
+    var hash      = win.location.hash.substring(1),
+        container = pjax.get('container'),
+        hasLines, node;
+
+    // Add ids for each line number in the file source view.
+    container.all('.linenums>li').each(function (lineNode, index) {
+        lineNode.set('id', 'l' + (index + 1));
+        lineNode.addClass('file-line');
+        hasLines = true;
+    });
+
+    // Scroll to the desired line.
+    if (hasLines && /^l\d+$/.test(hash)) {
+        if ((node = container.getById(hash))) {
+            win.scroll(0, node.getY());
+        }
+    }
+};
+
+pjax.initRoot = function () {
+    var terminators = /^(?:classes|files|modules)$/,
+        parts       = pjax._getPathRoot().split('/'),
+        root        = [],
+        i, len, part;
+
+    for (i = 0, len = parts.length; i < len; i += 1) {
+        part = parts[i];
+
+        if (part.match(terminators)) {
+            // Makes sure the path will end with a "/".
+            root.push('');
+            break;
+        }
+
+        root.push(part);
+    }
+
+    pjax.set('root', root.join('/'));
+};
+
+pjax.updateTabState = function (src) {
+    var hash = win.location.hash.substring(1),
+        defaultTab, node, tab, tabPanel;
+
+    function scrollToNode() {
+        if (node.hasClass('protected')) {
+            Y.one('#api-show-protected').set('checked', true);
+            pjax.updateVisibility();
+        }
+
+        if (node.hasClass('private')) {
+            Y.one('#api-show-private').set('checked', true);
+            pjax.updateVisibility();
+        }
+
+        setTimeout(function () {
+            // For some reason, unless we re-get the node instance here,
+            // getY() always returns 0.
+            var node = Y.one('#classdocs').getById(hash);
+            win.scrollTo(0, node.getY() - 70);
+        }, 1);
+    }
+
+    if (!classTabView) {
+        return;
+    }
+
+    if (src === 'hashchange' && !hash) {
+        defaultTab = 'index';
+    } else {
+        if (localStorage) {
+            defaultTab = localStorage.getItem('tab_' + pjax.getPath()) ||
+                'index';
+        } else {
+            defaultTab = 'index';
+        }
+    }
+
+    if (hash && (node = Y.one('#classdocs').getById(hash))) {
+        if ((tabPanel = node.ancestor('.api-class-tabpanel', true))) {
+            if ((tab = Y.one('#classdocs .api-class-tab.' + tabPanel.get('id')))) {
+                if (classTabView.get('rendered')) {
+                    Y.Widget.getByNode(tab).set('selected', 1);
+                } else {
+                    tab.addClass('yui3-tab-selected');
+                }
+            }
+        }
+
+        // Scroll to the desired element if this is a hash URL.
+        if (node) {
+            if (classTabView.get('rendered')) {
+                scrollToNode();
+            } else {
+                classTabView.once('renderedChange', scrollToNode);
+            }
+        }
+    } else {
+        tab = Y.one('#classdocs .api-class-tab.' + defaultTab);
+
+        // When the `defaultTab` node isn't found, `localStorage` is stale.
+        if (!tab && defaultTab !== 'index') {
+            tab = Y.one('#classdocs .api-class-tab.index');
+        }
+
+        if (classTabView.get('rendered')) {
+            Y.Widget.getByNode(tab).set('selected', 1);
+        } else {
+            tab.addClass('yui3-tab-selected');
+        }
+    }
+};
+
+pjax.updateVisibility = function () {
+    var container = pjax.get('container');
+
+    container.toggleClass('hide-inherited',
+            !Y.one('#api-show-inherited').get('checked'));
+
+    container.toggleClass('show-deprecated',
+            Y.one('#api-show-deprecated').get('checked'));
+
+    container.toggleClass('show-protected',
+            Y.one('#api-show-protected').get('checked'));
+
+    container.toggleClass('show-private',
+            Y.one('#api-show-private').get('checked'));
+
+    pjax.checkVisibility();
+};
+
+// -- Route Handlers -----------------------------------------------------------
+
+pjax.handleClasses = function (req, res, next) {
+    var status = res.ioResponse.status;
+
+    // Handles success and local filesystem XHRs.
+    if (res.ioResponse.readyState === 4 && (!status || (status >= 200 && status < 300))) {
+        pjax.initClassTabView();
+    }
+
+    next();
+};
+
+pjax.handleFiles = function (req, res, next) {
+    var status = res.ioResponse.status;
+
+    // Handles success and local filesystem XHRs.
+    if (res.ioResponse.readyState === 4 && (!status || (status >= 200 && status < 300))) {
+        pjax.initLineNumbers();
+    }
+
+    next();
+};
+
+// -- Event Handlers -----------------------------------------------------------
+
+pjax.onNavigate = function (e) {
+    var hash         = e.hash,
+        originTarget = e.originEvent && e.originEvent.target,
+        tab;
+
+    if (hash) {
+        tab = originTarget && originTarget.ancestor('.yui3-tab', true);
+
+        if (hash === win.location.hash) {
+            pjax.updateTabState('hashchange');
+        } else if (!tab) {
+            win.location.hash = hash;
+        }
+
+        e.preventDefault();
+        return;
+    }
+
+    // Only scroll to the top of the page when the URL doesn't have a hash.
+    this.set('scrollToTop', !e.url.match(/#.+$/));
+
+    bdNode.addClass('loading');
+};
+
+pjax.onOptionClick = function (e) {
+    pjax.updateVisibility();
+};
+
+pjax.onTabSelectionChange = function (e) {
+    var tab   = e.newVal,
+        tabId = tab.get('contentBox').getAttribute('href').substring(1);
+
+    selectedTab = tab;
+
+    // If switching from a previous tab (i.e., this is not the default tab),
+    // replace the history entry with a hash URL that will cause this tab to
+    // be selected if the user navigates away and then returns using the back
+    // or forward buttons.
+    if (e.prevVal && localStorage) {
+        localStorage.setItem('tab_' + pjax.getPath(), tabId);
+    }
+
+    pjax.checkVisibility(tab);
+};
+
+// -- Init ---------------------------------------------------------------------
+
+pjax.on('navigate', pjax.onNavigate);
+
+pjax.initRoot();
+pjax.upgrade();
+pjax.initClassTabView();
+pjax.initLineNumbers();
+pjax.updateVisibility();
+
+Y.APIList.rootPath = pjax.get('root');
+
+Y.one('#api-options').delegate('click', pjax.onOptionClick, 'input');
+
+Y.on('hashchange', function (e) {
+    pjax.updateTabState('hashchange');
+}, win);
+
+});
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/js/yui-prettify.js b/plugins/dali-script-v8/docs/dali-theme/assets/js/yui-prettify.js
new file mode 100644
index 0000000..18de864
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/js/yui-prettify.js
@@ -0,0 +1,17 @@
+YUI().use('node', function(Y) {
+    var code = Y.all('.prettyprint.linenums');
+    if (code.size()) {
+        code.each(function(c) {
+            var lis = c.all('ol li'),
+                l = 1;
+            lis.each(function(n) {
+                n.prepend('');
+                l++;
+            });
+        });
+        var h = location.hash;
+        location.hash = '';
+        h = h.replace('LINE_', 'LINENUM_');
+        location.hash = h;
+    }
+});
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/CHANGES.html b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/CHANGES.html
new file mode 100644
index 0000000..b50b841
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/CHANGES.html
@@ -0,0 +1,130 @@
+
+  
+    
+    Change Log
+  
+  
+    README
+
+    
    Known Issues
    
+    
      
+      
    • Perl formatting is really crappy.  Partly because the author is lazy and
+      partly because Perl is
+      hard to parse.
+      
    • On some browsers, <code> elements with newlines in the text
+      which use CSS to specify white-space:pre will have the newlines
+      improperly stripped if the element is not attached to the document at the time
+      the stripping is done.  Also, on IE 6, all newlines will be stripped from
+      <code> elements because of the way IE6 produces
+      innerHTML.  Workaround: use <pre> for code with
+      newlines.
+    
    
+
+    
    Change Log
    
+    
    29 March 2007
    
+    
      
+      
    • Added tests for PHP support
+        to address 
+      issue 3.
+      
    • Fixed
+      bug: prettyPrintOne was not halting.  This was not
+        reachable through the normal entry point.
+      
    • Fixed
+      bug: recursing into a script block or PHP tag that was not properly
+        closed would not silently drop the content.
+        (test)
+      
    • Fixed
+      bug: was eating tabs
+        (test)
+      
    • Fixed entity handling so that the caveat
+        
      
+          
      Caveats: please properly escape less-thans.  x&lt;y
+          instead of x<y, and use " instead of 
+          &quot; for string delimiters.
      
+        
      
+        is no longer applicable.
+      
    • Added noisefree's C#
+      patch
+      
    • Added a distribution that has comments and
+        whitespace removed to reduce download size from 45.5kB to 12.8kB.
+    
    
+    
    4 Jul 2008
    
+    
      
+      
    • Added language specific formatters that are triggered by the presence
+      of a lang-<language-file-extension>
      • 
+      
    • Fixed bug: python handling of '''string'''
+      
    • Fixed bug: / in regex [charsets] should not end regex
+    
    
+    
    5 Jul 2008
    
+    
      
+      
    • Defined language extensions for Lisp and Lua
+    
    
+    
    14 Jul 2008
    
+    
      
+      
    • Language handlers for F#, OCAML, SQL
+      
    • Support for nocode spans to allow embedding of line
+      numbers and code annotations which should not be styled or otherwise
+      affect the tokenization of prettified code.
+      See the issue 22
+      testcase.
+    
    
+    
    6 Jan 2009
    
+    
      
+      
    • Language handlers for Visual Basic, Haskell, CSS, and WikiText
      • 
+      
    • Added .mxml extension to the markup style handler for
+        Flex MXML files.  See
+        issue 37.
+      
    • Added .m extension to the C style handler so that Objective
+        C source files properly highlight.  See
+        issue 58.
+      
    • Changed HTML lexer to use the same embedded source mechanism as the
+        wiki language handler, and changed to use the registered
+        CSS handler for STYLE element content.
+    
    
+    
    21 May 2009
    
+    
      
+      
    • Rewrote to improve performance on large files.
+        See benchmarks.
      • 
+      
    • Fixed bugs with highlighting of Haskell line comments, Lisp
+        number literals, Lua strings, C preprocessor directives,
+        newlines in Wiki code on Windows, and newlines in IE6.
      • 
+    
    
+    
    14 August 2009
    
+    
      
+      
    • Fixed prettifying of <code> blocks with embedded newlines.
+    
    
+    
    3 October 2009
    
+    
      
+      
    • Fixed prettifying of XML/HTML tags that contain uppercase letters.
+    
    
+    
    19 July 2010
    
+    
      
+      
    • Added support for line numbers.  Bug
+        22
      • 
+      
    • Added YAML support.  Bug
+        123
      • 
+      
    • Added VHDL support courtesy Le Poussin.
      • 
+      
    • IE performance improvements.  Bug
+        102 courtesy jacobly.
      • 
+      
    • A variety of markup formatting fixes courtesy smain and thezbyg.
      • 
+      
    • Fixed copy and paste in IE[678].
+      
    • Changed output to use &#160; instead of
+        &nbsp; so that the output works when embedded in XML.
+        Bug
+        108.
      • 
+    
    
+  
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/COPYING b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/COPYING
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/COPYING
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.css b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.css
new file mode 100644
index 0000000..d44b3a2
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.css
@@ -0,0 +1 @@
+.pln{color:#000}@media screen{.str{color:#080}.kwd{color:#008}.com{color:#800}.typ{color:#606}.lit{color:#066}.pun,.opn,.clo{color:#660}.tag{color:#008}.atn{color:#606}.atv{color:#080}.dec,.var{color:#606}.fun{color:red}}@media print,projection{.str{color:#060}.kwd{color:#006;font-weight:bold}.com{color:#600;font-style:italic}.typ{color:#404;font-weight:bold}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:bold}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8{list-style-type:none}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee}
\ No newline at end of file
diff --git a/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.js b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.js
new file mode 100644
index 0000000..4845d05
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/assets/vendor/prettify/prettify-min.js
@@ -0,0 +1 @@
+window.PR_SHOULD_USE_CONTINUATION=true;var prettyPrintOne;var prettyPrint;(function(){var O=window;var j=["break,continue,do,else,for,if,return,while"];var v=[j,"auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"];var q=[v,"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"];var m=[q,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"];var y=[q,"abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient"];var T=[y,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,let,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var,virtual,where"];var s="all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,throw,true,try,unless,until,when,while,yes";var x=[q,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"];var t="caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END";var J=[j,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"];var g=[j,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"];var I=[j,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"];var B=[m,T,x,t+J,g,I];var f=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)\b/;var D="str";var A="kwd";var k="com";var Q="typ";var H="lit";var M="pun";var G="pln";var n="tag";var F="dec";var K="src";var R="atn";var o="atv";var P="nocode";var N="(?:^^\\.?|[+-]|[!=]=?=?|\\#|%=?|&&?=?|\\(|\\*=?|[+\\-]=|->|\\/=?|::?|<>?>?=?|,|;|\\?|@|\\[|~|{|\\^\\^?=?|\\|\\|?=?|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*";function l(ab){var af=0;var U=false;var ae=false;for(var X=0,W=ab.length;X122)){if(!(am<65||ai>90)){ah.push([Math.max(65,ai)|32,Math.min(am,90)|32])}if(!(am<97||ai>122)){ah.push([Math.max(97,ai)&~32,Math.min(am,122)&~32])}}}}ah.sort(function(aw,av){return(aw[0]-av[0])||(av[1]-aw[1])});var ak=[];var aq=[];for(var at=0;atau[0]){if(au[1]+1>au[0]){ao.push("-")}ao.push(V(au[1]))}}ao.push("]");return ao.join("")}function Y(an){var al=an.source.match(new RegExp("(?:\\[(?:[^\\x5C\\x5D]|\\\\[\\s\\S])*\\]|\\\\u[A-Fa-f0-9]{4}|\\\\x[A-Fa-f0-9]{2}|\\\\[0-9]+|\\\\[^ux0-9]|\\(\\?[:!=]|[\\(\\)\\^]|[^\\x5B\\x5C\\(\\)\\^]+)","g"));var aj=al.length;var ap=[];for(var am=0,ao=0;am=2&&ak==="["){al[am]=Z(ai)}else{if(ak!=="\\"){al[am]=ai.replace(/[a-zA-Z]/g,function(aq){var ar=aq.charCodeAt(0);return"["+String.fromCharCode(ar&~32,ar|32)+"]"})}}}}return al.join("")}var ac=[];for(var X=0,W=ab.length;X=0;){U[ae.charAt(ag)]=aa}}var ah=aa[1];var ac=""+ah;if(!ai.hasOwnProperty(ac)){aj.push(ah);ai[ac]=null}}aj.push(/[\0-\uffff]/);X=l(aj)})();var Z=V.length;var Y=function(aj){var ab=aj.sourceCode,aa=aj.basePos;var af=[aa,G];var ah=0;var ap=ab.match(X)||[];var al={};for(var ag=0,at=ap.length;ag=5&&"lang-"===ar.substring(0,5);if(ao&&!(ak&&typeof ak[1]==="string")){ao=false;ar=K}if(!ao){al[ai]=ar}}var ad=ah;ah+=ai.length;if(!ao){af.push(aa+ad,ar)}else{var an=ak[1];var am=ai.indexOf(an);var ae=am+an.length;if(ak[2]){ae=ai.length-ak[2].length;am=ae-an.length}var au=ar.substring(5);C(aa+ad,ai.substring(0,am),Y,af);C(aa+ad+am,an,r(au,an),af);C(aa+ad+ae,ai.substring(ae),Y,af)}}aj.decorations=af};return Y}function i(V){var Y=[],U=[];if(V.tripleQuotedStrings){Y.push([D,/^(?:\'\'\'(?:[^\'\\]|\\[\s\S]|\'{1,2}(?=[^\']))*(?:\'\'\'|$)|\"\"\"(?:[^\"\\]|\\[\s\S]|\"{1,2}(?=[^\"]))*(?:\"\"\"|$)|\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$))/,null,"'\""])}else{if(V.multiLineStrings){Y.push([D,/^(?:\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$)|\`(?:[^\\\`]|\\[\s\S])*(?:\`|$))/,null,"'\"`"])}else{Y.push([D,/^(?:\'(?:[^\\\'\r\n]|\\.)*(?:\'|$)|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/,null,"\"'"])}}if(V.verbatimStrings){U.push([D,/^@\"(?:[^\"]|\"\")*(?:\"|$)/,null])}var ab=V.hashComments;if(ab){if(V.cStyleComments){if(ab>1){Y.push([k,/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,null,"#"])}else{Y.push([k,/^#(?:(?:define|e(?:l|nd)if|else|error|ifn?def|include|line|pragma|undef|warning)\b|[^\r\n]*)/,null,"#"])}U.push([D,/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h(?:h|pp|\+\+)?|[a-z]\w*)>/,null])}else{Y.push([k,/^#[^\r\n]*/,null,"#"])}}if(V.cStyleComments){U.push([k,/^\/\/[^\r\n]*/,null]);U.push([k,/^\/\*[\s\S]*?(?:\*\/|$)/,null])}if(V.regexLiterals){var aa=("/(?=[^/*])(?:[^/\\x5B\\x5C]|\\x5C[\\s\\S]|\\x5B(?:[^\\x5C\\x5D]|\\x5C[\\s\\S])*(?:\\x5D|$))+/");U.push(["lang-regex",new RegExp("^"+N+"("+aa+")")])}var X=V.types;if(X){U.push([Q,X])}var W=(""+V.keywords).replace(/^ | $/g,"");if(W.length){U.push([A,new RegExp("^(?:"+W.replace(/[\s,]+/g,"|")+")\\b"),null])}Y.push([G,/^\s+/,null," \r\n\t\xA0"]);var Z=/^.[^\s\w\.$@\'\"\`\/\\]*/;U.push([H,/^@[a-z_$][a-z_$@0-9]*/i,null],[Q,/^(?:[@_]?[A-Z]+[a-z][A-Za-z_$@0-9]*|\w+_t\b)/,null],[G,/^[a-z_$][a-z_$@0-9]*/i,null],[H,new RegExp("^(?:0x[a-f0-9]+|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)(?:e[+\\-]?\\d+)?)[a-z]*","i"),null,"0123456789"],[G,/^\\[\s\S]?/,null],[M,Z,null]);return h(Y,U)}var L=i({keywords:B,hashComments:true,cStyleComments:true,multiLineStrings:true,regexLiterals:true});function S(W,ah,aa){var V=/(?:^|\s)nocode(?:\s|$)/;var ac=/\r\n?|\n/;var ad=W.ownerDocument;var ag=ad.createElement("li");while(W.firstChild){ag.appendChild(W.firstChild)}var X=[ag];function af(am){switch(am.nodeType){case 1:if(V.test(am.className)){break}if("br"===am.nodeName){ae(am);if(am.parentNode){am.parentNode.removeChild(am)}}else{for(var ao=am.firstChild;ao;ao=ao.nextSibling){af(ao)}}break;case 3:case 4:if(aa){var an=am.nodeValue;var ak=an.match(ac);if(ak){var aj=an.substring(0,ak.index);am.nodeValue=aj;var ai=an.substring(ak.index+ak[0].length);if(ai){var al=am.parentNode;al.insertBefore(ad.createTextNode(ai),am.nextSibling)}ae(am);if(!aj){am.parentNode.removeChild(am)}}}break}}function ae(al){while(!al.nextSibling){al=al.parentNode;if(!al){return}}function aj(am,at){var ar=at?am.cloneNode(false):am;var ap=am.parentNode;if(ap){var aq=aj(ap,1);var ao=am.nextSibling;aq.appendChild(ar);for(var an=ao;an;an=ao){ao=an.nextSibling;aq.appendChild(an)}}return ar}var ai=aj(al.nextSibling,0);for(var ak;(ak=ai.parentNode)&&ak.nodeType===1;){ai=ak}X.push(ai)}for(var Z=0;Z=U){aj+=2}if(Y>=ar){ac+=2}}}finally{if(au){au.style.display=ak}}}var u={};function d(W,X){for(var U=X.length;--U>=0;){var V=X[U];if(!u.hasOwnProperty(V)){u[V]=W}else{if(O.console){console.warn("cannot override language handler %s",V)}}}}function r(V,U){if(!(V&&u.hasOwnProperty(V))){V=/^\s*]*(?:>|$)/],[k,/^<\!--[\s\S]*?(?:-\->|$)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],[M,/^(?:<[%?]|[%?]>)/],["lang-",/^]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-js",/^]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),["default-markup","htm","html","mxml","xhtml","xml","xsl"]);d(h([[G,/^[\s]+/,null," \t\r\n"],[o,/^(?:\"[^\"]*\"?|\'[^\']*\'?)/,null,"\"'"]],[[n,/^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i],[R,/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/],[M,/^[=<>\/]+/],["lang-js",/^on\w+\s*=\s*\"([^\"]+)\"/i],["lang-js",/^on\w+\s*=\s*\'([^\']+)\'/i],["lang-js",/^on\w+\s*=\s*([^\"\'>\s]+)/i],["lang-css",/^style\s*=\s*\"([^\"]+)\"/i],["lang-css",/^style\s*=\s*\'([^\']+)\'/i],["lang-css",/^style\s*=\s*([^\"\'>\s]+)/i]]),["in.tag"]);d(h([],[[o,/^[\s\S]+/]]),["uq.val"]);d(i({keywords:m,hashComments:true,cStyleComments:true,types:f}),["c","cc","cpp","cxx","cyc","m"]);d(i({keywords:"null,true,false"}),["json"]);d(i({keywords:T,hashComments:true,cStyleComments:true,verbatimStrings:true,types:f}),["cs"]);d(i({keywords:y,cStyleComments:true}),["java"]);d(i({keywords:I,hashComments:true,multiLineStrings:true}),["bsh","csh","sh"]);d(i({keywords:J,hashComments:true,multiLineStrings:true,tripleQuotedStrings:true}),["cv","py"]);d(i({keywords:t,hashComments:true,multiLineStrings:true,regexLiterals:true}),["perl","pl","pm"]);d(i({keywords:g,hashComments:true,multiLineStrings:true,regexLiterals:true}),["rb"]);d(i({keywords:x,cStyleComments:true,regexLiterals:true}),["js"]);d(i({keywords:s,hashComments:3,cStyleComments:true,multilineStrings:true,tripleQuotedStrings:true,regexLiterals:true}),["coffee"]);d(h([],[[D,/^[\s\S]+/]]),["regex"]);function e(X){var W=X.langExtension;try{var U=b(X.sourceNode,X.pre);var V=U.sourceCode;X.sourceCode=V;X.spans=U.spans;X.basePos=0;r(W,V)(X);E(X)}catch(Y){if(O.console){console.log(Y&&Y.stack?Y.stack:Y)}}}function z(Y,X,W){var U=document.createElement("pre");U.innerHTML=Y;if(W){S(U,W,true)}var V={langExtension:X,numberLines:W,sourceNode:U,pre:1};e(V);return U.innerHTML}function c(aj){function ab(al){return document.getElementsByTagName(al)}var ah=[ab("pre"),ab("code"),ab("xmp")];var V=[];for(var ae=0;ae]*(?:>|$)/],[PR.PR_COMMENT,/^<\!--[\s\S]*?(?:-\->|$)/],[PR.PR_PUNCTUATION,/^(?:<[%?]|[%?]>)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],["lang-",/^]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-handlebars",/^]*type\s*=\s*['"]?text\/x-handlebars-template['"]?\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-js",/^]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i],[PR.PR_DECLARATION,/^{{[#^>/]?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{&?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{{>?\s*[\w.][^}]*}}}/],[PR.PR_COMMENT,/^{{![^}]*}}/]]),["handlebars","hbs"]);PR.registerLangHandler(PR.createSimpleLexer([[PR.PR_PLAIN,/^[ \t\r\n\f]+/,null," \t\r\n\f"]],[[PR.PR_STRING,/^\"(?:[^\n\r\f\\\"]|\\(?:\r\n?|\n|\f)|\\[\s\S])*\"/,null],[PR.PR_STRING,/^\'(?:[^\n\r\f\\\']|\\(?:\r\n?|\n|\f)|\\[\s\S])*\'/,null],["lang-css-str",/^url\(([^\)\"\']*)\)/i],[PR.PR_KEYWORD,/^(?:url|rgb|\!important|@import|@page|@media|@charset|inherit)(?=[^\-\w]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|(?:\\[0-9a-f]+ ?))(?:[_a-z0-9\-]|\\(?:\\[0-9a-f]+ ?))*)\s*:/i],[PR.PR_COMMENT,/^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//],[PR.PR_COMMENT,/^(?:)/],[PR.PR_LITERAL,/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],[PR.PR_LITERAL,/^#(?:[0-9a-f]{3}){1,2}/i],[PR.PR_PLAIN,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i],[PR.PR_PUNCTUATION,/^[^\s\w\'\"]+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_KEYWORD,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_STRING,/^[^\)\"\']+/]]),["css-str"]);
\ No newline at end of file
diff --git a/plugins/dali-script-v8/docs/dali-theme/layouts/main.handlebars b/plugins/dali-script-v8/docs/dali-theme/layouts/main.handlebars
new file mode 100644
index 0000000..7ea2bd4
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/layouts/main.handlebars
@@ -0,0 +1,55 @@
+
+
+
+    
+    {{htmlTitle}}
+    
+    
+    
+    
+    
+
+
+
+
    
+    
    
+        
    
+            {{#if projectLogo}}
+                
    
+            {{else}}
+                
    
+            {{/if}}
+        
    
+        
    
+            API Docs for: {{projectVersion}}
+        
    
+    
    
+    
    
+
+        
    
+            
+        
    
+        
    
+            {{>options}}
+            
    
+                
    
+                    
    
+{{>layout_content}}
+                    
    
+                
    
+            
    
+        
    
+    
    
+
    
+
+
+
+
+
+
+
+
+
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/layouts/xhr.handlebars b/plugins/dali-script-v8/docs/dali-theme/layouts/xhr.handlebars
new file mode 100644
index 0000000..c66f7d3
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/layouts/xhr.handlebars
@@ -0,0 +1,7 @@
+
    
+    
    
+{{>layout_content}}
+    
    
+
    
+
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/attrs.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/attrs.handlebars
new file mode 100644
index 0000000..a957ce0
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/attrs.handlebars
@@ -0,0 +1,141 @@
+
    
+     {{! For backwards compatibility }}
+    
    {{name}}
    
+    {{#crossLink type}}{{/crossLink}}
+
+    {{#if deprecated}}
+        deprecated
+    {{/if}}
+
+    {{#if access}}
+        {{access}}
+    {{/if}}
+
+    {{#if final}}
+        final
+    {{/if}}
+
+    {{#if static}}
+        static
+    {{/if}}
+
+    {{#if optional}}
+        optional
+    {{/if}}
+
+    {{#if required}}
+        required
+    {{/if}}
+
+    {{#if readonly}}
+        readonly
+    {{/if}}
+
+    
    
+        {{#if overwritten_from}}
+            
    Inherited from
+            
+                {{overwritten_from/class}}
+            
+            {{#if foundAt}}
+            but overwritten in
+            {{/if}}
+        {{else}}
+            {{#if extended_from}}
+                
    Inherited from
+                {{extended_from}}:
+            {{else}}
+                {{#providedBy}}
+                    
    Provided by the {{.}} module.
    
+                {{/providedBy}}
+                
    
+                {{#if foundAt}}
+                Defined in
+                {{/if}}
+            {{/if}}
+        {{/if}}
+        {{#if foundAt}}
+        `{{{file}}}:{{{line}}}`
+        {{/if}}
+        
    
+
+        {{#if deprecationMessage}}
+            
    Deprecated: {{deprecationMessage}}
    
+        {{/if}}
+
+        {{#if since}}
+            
    Available since {{since}}
    
+        {{/if}}
+    
    
+
+    
    
+        {{{attrDescription}}}
+    
    
+
+    {{#if default}}
+        
    Default: {{default}}
    
+    {{/if}}
+
+    {{#if emit}}
+        
    
+            
    Fires event {{name}}Change
    
+
+            
    
+            Fires when the value for the configuration attribute `{{{name}}}` is
+            changed. You can listen for the event using the `on` method if you
+            wish to be notified before the attribute's value has changed, or
+            using the `after` method if you wish to be notified after the
+            attribute's value has changed.
+            
    
+
+            
    
+                
    Parameters:
    
+
+                
      
+                    
    • 
+                        e
+                        {{#crossLink "EventFacade"}}{{/crossLink}}
+
+                        
      
+                            An Event Facade object with the following
+                            attribute-specific properties added:
+                        
      
+
+                        
        
+                            
      • 
+                                prevVal
+                                Any
+                                
        The value of the attribute, prior to it being set.
        
+                            
        • 
+                            
      • 
+                                newVal
+                                Any
+                                
        The value the attribute is to be set to.
        
+                            
        • 
+                            
      • 
+                                attrName
+                                {{#crossLink "String"}}{{/crossLink}}
+                                
        The name of the attribute being set.
        
+                            
        • 
+                            
      • 
+                                subAttrName
+                                {{#crossLink "String"}}{{/crossLink}}
+                                
        If setting a property within the attribute's value, the name of the sub-attribute property being set.
        
+                            
        • 
+                        
      
+                    
      • 
+                
    
+            
    
+        
    
+    {{/if}}
+
+    {{#example}}
+        
    
+            
    Example:
    
+
+            
    
+                {{{.}}}
+            
    
+        
    
+    {{/example}}
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/classes.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/classes.handlebars
new file mode 100644
index 0000000..0d0a937
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/classes.handlebars
@@ -0,0 +1,203 @@
+
    {{name}} Class
    
+
    
+    {{#if uses}}
+        
    
+            Uses
+            
      
+                {{#uses}}
+                    
    • {{.}}
      • 
+                {{/uses}}
+            
    
+        
    
+    {{/if}}
+
+    {{#if extends}}
+        
    
+            Extends {{#crossLink extends}}{{/crossLink}}
+        
    
+    {{/if}}
+
+    {{#if foundAt}}
+        
    
+            Defined in: `{{{file}}}:{{{line}}}`
+        
    
+    {{/if}}
+
+    {{#if module}}
+        {{#if submodule}}
+            Module: {{#crossLinkModule submodule}}{{/crossLinkModule}}
    
+            Parent Module: {{#crossLinkModule module}}{{/crossLinkModule}}
+        {{else}}
+            Module: {{#crossLinkModule module}}{{/crossLinkModule}}
+        {{/if}}
+    {{/if}}
+
+    {{#if since}}
+        
    Available since {{since}}
    
+    {{/if}}
+
    
+
+{{#if deprecated}}
+    
    
+        
    
+        {{#if deprecationMessage}}
+            Deprecated: {{deprecationMessage}}
+        {{else}}
+            This class is deprecated.
+        {{/if}}
+        
    
+    
    
+{{/if}}
+
+
    
+    {{{classDescription}}}
+
    
+
+{{#is_constructor}}
+    
    
+        
    Constructor
    
+        {{>method}}
+    
    
+{{/is_constructor}}
+
+
    
+    
+
+    
    
+        
    
+            
    Item Index
    
+
+            {{#if methods}}
+                
    
+                    
    Methods
    
+
+                    
      
+                        {{#methods}}
+                            
    • 
+                                {{name}}
+
+                                {{#if static}}
+                                    static
+                                {{/if}}
+                                {{#if deprecated}}
+                                    deprecated
+                                {{/if}}
+                            
      • 
+                        {{/methods}}
+                    
    
+                
    
+            {{/if}}
+
+            {{#if properties}}
+                
    
+                    
    Properties
    
+
+                    
      
+                        {{#properties}}
+                            
    • 
+                                {{name}}
+
+                                {{#if static}}
+                                    static
+                                {{/if}}
+                                {{#if deprecated}}
+                                    deprecated
+                                {{/if}}
+                            
      • 
+                        {{/properties}}
+                    
    
+                
    
+            {{/if}}
+
+            {{#if attrs}}
+                
    
+                    
    Attributes
    
+
+                    
      
+                        {{#attrs}}
+                            
    • 
+                                {{name}}
+                            
      • 
+                        {{/attrs}}
+                    
    
+                
    
+            {{/if}}
+
+            {{#if events}}
+                
    
+                    
    Events
    
+
+                    
      
+                        {{#events}}
+                            
    • 
+                                {{name}}
+
+                                {{#if static}}
+                                    static
+                                {{/if}}
+                                {{#if deprecated}}
+                                    deprecated
+                                {{/if}}
+                            
      • 
+                        {{/events}}
+                    
    
+                
    
+            {{/if}}
+        
    
+
+        {{#if methods}}
+            
    
+                
    Methods
    
+
+                {{#methods}}
+{{>method}}
+                {{/methods}}
+            
    
+        {{/if}}
+
+        {{#if properties}}
+            
    
+                
    Properties
    
+
+                {{#properties}}
+                    {{>props}}
+                {{/properties}}
+            
    
+        {{/if}}
+
+        {{#if attrs}}
+            
    
+                
    Attributes
    
+
+                {{#attrs}}
+                    {{>attrs}}
+                {{/attrs}}
+            
    
+        {{/if}}
+
+        {{#if events}}
+            
    
+                
    Events
    
+
+                {{#events}}
+                    {{>events}}
+                {{/events}}
+            
    
+        {{/if}}
+    
    
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/events.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/events.handlebars
new file mode 100644
index 0000000..cb7a6b5
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/events.handlebars
@@ -0,0 +1,137 @@
+
    
+    
    {{name}}
    
+    {{#crossLink type}}{{/crossLink}}
+
+    {{#if deprecated}}
+        deprecated
+    {{/if}}
+
+    {{#if access}}
+        {{access}}
+    {{/if}}
+
+    {{#if final}}
+        final
+    {{/if}}
+
+    {{#if static}}
+        static
+    {{/if}}
+
+    
    
+        {{#if overwritten_from}}
+            
    Inherited from
+            
+                {{overwritten_from/class}}
+            
+            {{#if foundAt}}
+            but overwritten in
+            {{/if}}
+        {{else}}
+            {{#if extended_from}}
+                
    Inherited from
+                {{extended_from}}:
+            {{else}}
+                {{#providedBy}}
+                    
    Provided by the {{.}} module.
    
+                {{/providedBy}}
+                
    
+                {{#if foundAt}}
+                Defined in
+                {{/if}}
+            {{/if}}
+        {{/if}}
+        {{#if foundAt}}
+        `{{{file}}}:{{{line}}}`
+        {{/if}}
+        
    
+
+        {{#if deprecationMessage}}
+            
    Deprecated: {{deprecationMessage}}
    
+        {{/if}}
+
+        {{#if since}}
+            
    Available since {{since}}
    
+        {{/if}}
+    
    
+
+    
    
+        {{{eventDescription}}}
+    
    
+
+    {{#if params}}
+        
    
+            
    Event Payload:
    
+
+            
      
+            {{#params}}
+                
    • 
+                    {{#if optional}}
+                        [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                        {{#crossLink type}}{{/crossLink}}
+                        optional
+                    {{else}}
+                        {{name}}
+                        {{#crossLink type}}{{/crossLink}}
+                    {{/if}}
+
+                    {{#if multiple}}
+                        Multiple
+                    {{/if}}
+
+                    
      
+                        {{{description}}}
+                    
      
+
+                    {{#if props}}
+                        
        
+                            {{#props}}
+                            
      • 
+                                {{#if optional}}
+                                    [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                                    {{#crossLink type}}{{/crossLink}}
+                                    optional
+                                {{else}}
+                                    {{name}}
+                                    {{#crossLink type}}{{/crossLink}}
+                                {{/if}}
+
+                                
        
+                                    {{{description}}}
+                                
        
+
+                                {{#if props}}
+                                    
          
+                                        {{#props}}
+                                        
        • 
+                                            {{name}}
+                                            {{#crossLink type}}{{/crossLink}}
+
+                                            
          
+                                                {{{description}}}
+                                            
          
+                                        
          • 
+                                        {{/props}}
+                                    
        
+                                {{/if}}
+                            
        • 
+                            {{/props}}
+                        
      
+                    {{/if}}
+                
      • 
+            {{/params}}
+            
    
+        
    
+    {{/if}}
+
+
+    {{#example}}
+        
    
+            
    Example:
    
+
+            
    
+                {{{.}}}
+            
    
+        
    
+    {{/example}}
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/files.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/files.handlebars
new file mode 100644
index 0000000..fccd476
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/files.handlebars
@@ -0,0 +1,7 @@
+
    File: {{fileName}}
    
+
+
    
+    
    +{{fileData}}
+    
    
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/index.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/index.handlebars
new file mode 100644
index 0000000..29a0e85
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/index.handlebars
@@ -0,0 +1,21 @@
+    
    
+        
    
+            
    
+            Browse to a module or class using the sidebar to view its API documentation.
+            
    
+
+            
    Keyboard Shortcuts
    
+
+            
      
+                
    • Press s to focus the API search box.
      • 
+
+                
    • Use Up and Down to select classes, modules, and search results.
      • 
+
+                
    • With the API search box or sidebar focused, use ⌘-Left or ⌘-Right to switch sidebar tabs.
      • 
+
+                
    • With the API search box or sidebar focused, use Ctrl+Left and Ctrl+Right to switch sidebar tabs.
      • 
+            
    
+        
    
+    
    
+
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/method.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/method.handlebars
new file mode 100644
index 0000000..664d79b
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/method.handlebars
@@ -0,0 +1,212 @@
+
    
+    
    {{name}}
    
+
+    {{#if params}}
+        
    
+            (
      
+            {{#params}}
+                
    • 
+                    {{#if optional}}
+                        [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                    {{else}}
+                        {{name}}
+                    {{/if}}
+                
      • 
+            {{/params}}
+            
    )
+        
    
+    {{else}}
+        ()
+    {{/if}}
+
+    {{#if return}}
+        
+            {{#crossLink returnType}}{{/crossLink}}
+        
+    {{/if}}
+
+    {{#if deprecated}}
+        deprecated
+    {{/if}}
+
+    {{#if access}}
+        {{access}}
+    {{/if}}
+
+    {{#if final}}
+        final
+    {{/if}}
+
+    {{#if static}}
+        static
+    {{/if}}
+
+    {{#if chainable}}
+        chainable
+    {{/if}}
+
+    {{#if async}}
+        async
+    {{/if}}
+
+    
    
+        {{#if overwritten_from}}
+            
    Inherited from
+            
+                {{overwritten_from/class}}
+            
+            {{#if foundAt}}
+            but overwritten in
+            {{/if}}
+        {{else}}
+            {{#if extended_from}}
+                
    Inherited from
+                {{extended_from}}:
+            {{else}}
+                {{#providedBy}}
+                    
    Provided by the {{.}} module.
    
+                {{/providedBy}}
+                
    
+                {{#if foundAt}}
+                Defined in
+                {{/if}}
+            {{/if}}
+        {{/if}}
+        {{#if foundAt}}
+        `{{{file}}}:{{{line}}}`
+        {{/if}}
+        
    
+
+
+        {{#if deprecationMessage}}
+            
    Deprecated: {{deprecationMessage}}
    
+        {{/if}}
+
+        {{#if since}}
+            
    Available since {{since}}
    
+        {{/if}}
+    
    
+
+    
    
+        {{{methodDescription}}}
+    
    
+
+    {{#if params}}
+        
    
+            
    Parameters:
    
+
+            
      
+            {{#params}}
+                
    • 
+                    {{#if optional}}
+                        [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                        {{#crossLink type}}{{/crossLink}}
+                        optional
+                    {{else}}
+                        {{name}}
+                        {{#crossLink type}}{{/crossLink}}
+                    {{/if}}
+
+                    {{#if multiple}}
+                        multiple
+                    {{/if}}
+
+                    
      
+                        {{{description}}}
+                    
      
+
+                    {{#if props}}
+                        
        
+                            {{#props}}
+                            
      • 
+                                {{#if optional}}
+                                    [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                                    {{#crossLink type}}{{/crossLink}}
+                                    optional
+                                {{else}}
+                                    {{name}}
+                                    {{#crossLink type}}{{/crossLink}}
+                                {{/if}}
+
+                                
        
+                                    {{{description}}}
+                                
        
+
+                                {{#if props}}
+                                    
          
+                                        {{#props}}
+                                        
        • 
+                                            {{#if optional}}
+                                                [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                                                {{#crossLink type}}{{/crossLink}}
+                                                optional
+                                            {{else}}
+                                                {{name}}
+                                                {{#crossLink type}}{{/crossLink}}
+                                            {{/if}}
+
+                                            
          
+                                                {{{description}}}
+                                            
          
+                                        
          • 
+                                        {{/props}}
+                                    
        
+                                {{/if}}
+                            
        • 
+                            {{/props}}
+                        
      
+                    {{/if}}
+                
      • 
+            {{/params}}
+            
    
+        
    
+    {{/if}}
+
+    {{#return}}
+        
    
+            
    Returns:
    
+
+            
    
+                {{#if description}}
+                    {{#if type}}
+                        {{#crossLink type}}{{/crossLink}}:
+                    {{/if}}
+                    {{{description}}}
+                {{else}}
+                    {{#if type}}
+                        {{#crossLink type}}{{/crossLink}}:
+                    {{/if}}
+                {{/if}}
+            
    
+        
    
+    {{/return}}
+
+    {{#throws}}
+        
    
+            
    Throws:
    
+
+            
    
+                {{#if description}}
+                    {{#if type}}
+                        {{#crossLink type}}{{/crossLink}}:
+                    {{/if}}
+                    {{{description}}}
+                {{else}}
+                    {{#if type}}
+                        {{#crossLink type}}{{/crossLink}}:
+                    {{/if}}
+                {{/if}}
+            
    
+        
    
+    {{/throws}}
+
+    {{#example}}
+        
    
+            
    Example:
    
+
+            
    
+                {{{.}}}
+            
    
+        
    
+    {{/example}}
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/module.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/module.handlebars
new file mode 100644
index 0000000..190007f
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/module.handlebars
@@ -0,0 +1,92 @@
+
    {{name}} Module
    
+
    
+    {{#extra}}
+        {{#selleck}}
+            User Guide & Examples
+        {{/selleck}}
+    {{/extra}}
+
+    {{#if requires}}
+        
    
+            Requires
+            
      
+                {{#requires}}
+                    
    • {{#crossLinkModule .}}{{/crossLinkModule}}
      • 
+                {{/requires}}
+            
    
+        
    
+    {{/if}}
+
+    {{#if foundAt}}
+        
    
+            Defined in: `{{{file}}}:{{{line}}}`
+        
    
+    {{/if}}
+
+    {{#if since}}
+        
    Available since {{since}}
    
+    {{/if}}
+
    
+
+{{#if deprecated}}
+    
    
+        
    
+        {{#if deprecationMessage}}
+            Deprecated: {{deprecationMessage}}
+        {{else}}
+            This module is deprecated.
+        {{/if}}
+        
    
+    
    
+{{/if}}
+
+
    
+    {{{moduleDescription}}}
+
    
+
+{{#example}}
+    
    
+        
    Example:
    
+        
    
+            {{{.}}}
+        
    
+    
    
+{{/example}}
+
+
    
+    
    
+        {{#if moduleClasses}}
+            
    This module provides the following classes:
    
+
+            
+        {{/if}}
+    
    
+
+    
    
+        {{#if subModules}}
+            
    This module is a rollup of the following modules:
    
+
+            
+        {{/if}}
+    
    
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/options.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/options.handlebars
new file mode 100644
index 0000000..2b26210
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/options.handlebars
@@ -0,0 +1,23 @@
+    
    
+        Show:
+        
+
+        
+
+        
+        
+
+    
    
+
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/props.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/props.handlebars
new file mode 100644
index 0000000..696e720
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/props.handlebars
@@ -0,0 +1,119 @@
+
    
+    
    {{name}}
    
+    {{#crossLink type}}{{/crossLink}}
+
+    {{#if deprecated}}
+        deprecated
+    {{/if}}
+
+    {{#if access}}
+        {{access}}
+    {{/if}}
+
+    {{#if final}}
+        final
+    {{/if}}
+
+    {{#if static}}
+        static
+    {{/if}}
+
+    
    
+        {{#if overwritten_from}}
+            
    Inherited from
+            
+                {{overwritten_from/class}}
+            
+            {{#if foundAt}}
+            but overwritten in
+            {{/if}}
+        {{else}}
+            {{#if extended_from}}
+                
    Inherited from
+                {{extended_from}}:
+            {{else}}
+                {{#providedBy}}
+                    
    Provided by the {{.}} module.
    
+                {{/providedBy}}
+                
    
+                {{#if foundAt}}
+                Defined in
+                {{/if}}
+            {{/if}}
+        {{/if}}
+        {{#if foundAt}}
+        `{{{file}}}:{{{line}}}`
+        {{/if}}
+        
    
+
+        {{#if deprecationMessage}}
+            
    Deprecated: {{deprecationMessage}}
    
+        {{/if}}
+
+        {{#if since}}
+            
    Available since {{since}}
    
+        {{/if}}
+    
    
+
+    
    
+        {{{propertyDescription}}}
+    
    
+
+    {{#if default}}
+        
    Default: {{default}}
    
+    {{/if}}
+
+    {{#example}}
+        
    
+            
    Example:
    
+
+            
    
+                {{{.}}}
+            
    
+        
    
+    {{/example}}
+
+    {{#if subprops}}
+        
    Sub-properties:
    
+
+        
      
+            {{#subprops}}
+            
    • 
+                {{#if optional}}
+                    [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                    {{#crossLink type}}{{/crossLink}}
+                    optional
+                {{else}}
+                    {{name}}
+                    {{#crossLink type}}{{/crossLink}}
+                {{/if}}
+
+                
      
+                    {{{description}}}
+                
      
+
+                {{#if subprops}}
+                    
        
+                        {{#subprops}}
+                        
      • 
+                            {{#if optional}}
+                                [{{name}}{{#if optdefault}}={{optdefault}}{{/if}}]
+                                {{#crossLink type}}{{/crossLink}}
+                                optional
+                            {{else}}
+                                {{name}}
+                                {{#crossLink type}}{{/crossLink}}
+                            {{/if}}
+
+                            
        
+                                {{{description}}}
+                            
        
+                        
        • 
+                        {{/subprops}}
+                    
      
+                {{/if}}
+            
      • 
+            {{/subprops}}
+        
    
+    {{/if}}
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/partials/sidebar.handlebars b/plugins/dali-script-v8/docs/dali-theme/partials/sidebar.handlebars
new file mode 100644
index 0000000..a8500c5
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/partials/sidebar.handlebars
@@ -0,0 +1,27 @@
+
    
+    
    APIs
    
+    
    
+        
+
+        
    
+            
+        
    
+
+        
    
+            
+
+            
+        
    
+    
    
+
    
diff --git a/plugins/dali-script-v8/docs/dali-theme/theme.json b/plugins/dali-script-v8/docs/dali-theme/theme.json
new file mode 100644
index 0000000..d540f15c
--- /dev/null
+++ b/plugins/dali-script-v8/docs/dali-theme/theme.json
@@ -0,0 +1,4 @@
+{
+    "yuiGridsUrl": "http://yui.yahooapis.com/3.9.1/build/cssgrids/cssgrids-min.css",
+    "yuiSeedUrl": "http://yui.yahooapis.com/combo?3.9.1/build/yui/yui-min.js"
+}
diff --git a/plugins/dali-script-v8/docs/gmon.out b/plugins/dali-script-v8/docs/gmon.out
new file mode 100644
index 0000000000000000000000000000000000000000..04ee4675971c48c8eeb5c1b19a8f76f7748929de
GIT binary patch
literal 1963
zcmYe#&Cg?GKm!LP9l#q~k^@x5H>f07@B>s(Sp{MYSTF#}=|mPZP=%=QQbbZY0V-$?
NH3qC5Cdi8vAOIr{AOipZ

literal 0
HcmV?d00001

diff --git a/plugins/dali-script-v8/docs/yuidoc.json b/plugins/dali-script-v8/docs/yuidoc.json
new file mode 100644
index 0000000..89a27cb
--- /dev/null
+++ b/plugins/dali-script-v8/docs/yuidoc.json
@@ -0,0 +1,13 @@
+{
+    "name": "DALI JavaScript API",
+    "description": "DALI is a dynamic animtaion library for building advanced 3D applications",
+    "version": "1.0.0",
+    "themedir": "dali-theme",
+    "url": "https://review.tizen.org/gerrit/platform/core/uifw/dali-core",
+    "options": {
+        "outdir": "generated",
+        "markdown": {
+          "gfm":"true"
+       }
+    }
+}
diff --git a/plugins/dali-script-v8/file.list b/plugins/dali-script-v8/file.list
new file mode 100644
index 0000000..13300ef
--- /dev/null
+++ b/plugins/dali-script-v8/file.list
@@ -0,0 +1,57 @@
+# Add local source files here
+
+v8_plugin_dir =\
+ $(plugin_src_dir)/dali-script-v8/src
+
+script_v8_plugin_src_files = \
+   $(v8_plugin_dir)/dali-script-v8.cpp \
+   $(v8_plugin_dir)/utils/v8-utils.cpp \
+   $(v8_plugin_dir)/dali-wrapper.cpp \
+   $(v8_plugin_dir)/shared/base-wrapped-object.cpp \
+   $(v8_plugin_dir)/shared/object-template-helper.cpp \
+   $(v8_plugin_dir)/actors/actor-wrapper.cpp \
+   $(v8_plugin_dir)/actors/actor-api.cpp \
+   $(v8_plugin_dir)/actors/layer-api.cpp \
+   $(v8_plugin_dir)/actors/text-actor-api.cpp \
+   $(v8_plugin_dir)/actors/image-actor-api.cpp \
+   $(v8_plugin_dir)/actors/camera-actor-api.cpp \
+   $(v8_plugin_dir)/actors/mesh-actor-api.cpp \
+   $(v8_plugin_dir)/actors/renderable-actor-api.cpp \
+   $(v8_plugin_dir)/constants/constants-wrapper.cpp \
+   $(v8_plugin_dir)/text/font-api.cpp \
+   $(v8_plugin_dir)/text/font-wrapper.cpp \
+   $(v8_plugin_dir)/animation/animation-api.cpp \
+   $(v8_plugin_dir)/animation/animation-wrapper.cpp \
+   $(v8_plugin_dir)/animation/path-api.cpp \
+   $(v8_plugin_dir)/animation/path-wrapper.cpp \
+   $(v8_plugin_dir)/stage/stage-wrapper.cpp \
+   $(v8_plugin_dir)/events/event-object-generator.cpp \
+   $(v8_plugin_dir)/events/pan-gesture-detector-api.cpp \
+   $(v8_plugin_dir)/events/pan-gesture-detector-wrapper.cpp \
+   $(v8_plugin_dir)/stage/stage-api.cpp \
+   $(v8_plugin_dir)/image/image-attributes-api.cpp \
+   $(v8_plugin_dir)/shader-effects/shader-effect-api.cpp \
+   $(v8_plugin_dir)/shader-effects/shader-effect-wrapper.cpp \
+   $(v8_plugin_dir)/image/image-attributes-wrapper.cpp \
+   $(v8_plugin_dir)/image/image-wrapper.cpp \
+   $(v8_plugin_dir)/image/image-api.cpp \
+   $(v8_plugin_dir)/image/buffer-image-api.cpp \
+   $(v8_plugin_dir)/image/native-image-api.cpp \
+   $(v8_plugin_dir)/image/frame-buffer-image-api.cpp \
+   $(v8_plugin_dir)/image/resource-image-api.cpp \
+   $(v8_plugin_dir)/image/nine-patch-image-api.cpp \
+   $(v8_plugin_dir)/object/handle-wrapper.cpp \
+   $(v8_plugin_dir)/object/property-value-wrapper.cpp \
+   $(v8_plugin_dir)/signals/signal-manager.cpp \
+   $(v8_plugin_dir)/render-tasks/render-task-list-api.cpp \
+   $(v8_plugin_dir)/render-tasks/render-task-list-wrapper.cpp \
+   $(v8_plugin_dir)/render-tasks/render-task-api.cpp \
+   $(v8_plugin_dir)/render-tasks/render-task-wrapper.cpp \
+   $(v8_plugin_dir)/toolkit/builder/builder-api.cpp \
+   $(v8_plugin_dir)/toolkit/builder/builder-wrapper.cpp \
+   $(v8_plugin_dir)/toolkit/focus-manager/keyboard-focus-manager-api.cpp \
+   $(v8_plugin_dir)/toolkit/focus-manager/keyboard-focus-manager-wrapper.cpp \
+   $(v8_plugin_dir)/signals/dali-any-javascript-converter.cpp \
+   $(v8_plugin_dir)/garbage-collector/garbage-collector.cpp \
+   $(v8_plugin_dir)/module-loader/module.cpp \
+   $(v8_plugin_dir)/module-loader/module-loader.cpp
diff --git a/plugins/dali-script-v8/src/actors/actor-api.cpp b/plugins/dali-script-v8/src/actors/actor-api.cpp
new file mode 100644
index 0000000..ebc1fa7
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/actor-api.cpp
@@ -0,0 +1,715 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "actor-api.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace  // unanmed namespace
+{
+Actor GetActor( v8::Isolate* isolate, const v8::FunctionCallbackInfo& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return Actor::DownCast( handleWrapper->mHandle );
+}
+} //unanmed namespace
+
+
+namespace TextViewApi
+{
+ Actor New( const v8::FunctionCallbackInfo< v8::Value >& args )
+ {
+   return Dali::Toolkit::TextView::New();
+ }
+}
+
+/***************************************
+ * ACTOR API FUNCTIONS
+ ****************************************/
+/**
+ * Constructor
+ *
+ * @for Actor
+ * @constructor
+ * @method Actor
+ * @return {Object} actor
+ */
+Actor ActorApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  return Actor::New();
+}
+
+/**
+ * get the actors unique id
+ *
+ * @for Actor
+ * @method getId
+ * @return {Integer} id
+ */
+void ActorApi::GetId( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, actor.GetId() ) );
+}
+
+/**
+ * Query whether an actor is the root actor, which is owned by the Stage
+ *
+ * @for Actor
+ * @method isRoot
+ * @return {Boolean} true if it is root
+ *
+ */
+void ActorApi::IsRoot( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, actor.IsRoot() ) );
+}
+
+/**
+ *
+ * Query whether the actor is connected to the Stage.
+ * When an actor is connected, it will be directly or indirectly parented to the root Actor.
+ * The root Actor is provided automatically by dali.stage, and is always considered to be connected.
+ *
+ * @for Actor
+ * @method onStage
+ * @return {Boolean} True if the actor is connected to the Stage
+ */
+void ActorApi::OnStage( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, actor.OnStage() ) );
+}
+
+/**
+ * Query whether an actor is a layer
+ *
+ * @for Actor
+ * @method isLayer
+ * @return {Boolean} true if it is a layer
+ */
+void ActorApi::IsLayer( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, actor.IsLayer() ) );
+}
+
+/**
+ * Gets the layer in which the actor is present.
+ *
+ * @for Actor
+ * @method getLayer
+ * @return {Object} Layer
+ */
+void ActorApi::GetLayer( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+  Layer layer = actor.GetLayer();
+  if( layer ) // actors don't always have a layer
+  {
+    v8::Handle < v8::Object > wrappedLayer = ActorWrapper::ActorWrapper::WrapActor( isolate, layer, ActorWrapper::LAYER_ACTOR );
+    args.GetReturnValue().Set( wrappedLayer );
+  }
+  // else return an empty object
+}
+
+/**
+ * Adds a child Actor to this Actor.
+ *
+ * NOTE! if the child already has a parent, it will be removed from old parent
+ * and reparented to this actor. This may change childs position, color, shader effect,
+ * scale etc as it now inherits them from this actor
+ *
+ * Pre-conditions
+ * - The child actor is not the same as the parent actor.
+ * - The actor is not the Root actor
+
+ * Once added The child will be referenced by its parent. This means that the child will be kept alive,
+ * even if the handle passed into this method is reset or destroyed.
+ *
+ * @for Actor
+ * @method add
+ * @param {Object} Actor
+ */
+void ActorApi::AddActor( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor parent = GetActor( isolate, args );
+  bool found(false);
+  Actor child = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    parent.Add( child );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "child parameter missing" );
+  }
+}
+
+/**
+ * Removes a child Actor from this Actor.
+ *
+ * If the actor was not a child of this actor, this is a no-op.
+ *
+ * Preconditions:
+ * -  The child actor is not the same as the parent actor.
+ *
+ * @for Actor
+ * @param{Object} Actor the child actor
+ * @method Remove
+ */
+void ActorApi::RemoveActor( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor parent = GetActor( isolate, args );
+  bool found( false );
+  Actor child = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+
+  if( found )
+  {
+    parent.Remove( child );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "child parameter missing" );
+  }
+}
+
+/**
+ * Checks whether an Actor is equal to this Actor.
+ *
+ * @for Actor
+ * @method iIsEqualTo
+ * @param {Object} Actor
+ */
+void ActorApi::IsEqualTo( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor self = GetActor( isolate, args );
+  bool found( false );
+
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    args.GetReturnValue().Set( v8::Boolean::New( isolate, (actor == self) ) );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "actor parameter missing" );
+  }
+}
+
+/** Removes an actor from its parent.
+ *
+ * If the actor has no parent, this method does nothing.
+ *
+ * @for Actor
+ * @method Unparent
+ */
+void ActorApi::Unparent( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+  actor.Unparent();
+}
+
+/**
+ * get number of child actors
+ *
+ * @for Actor
+ * @method getChildCount
+ * @return {Integer} count
+ */
+void ActorApi::GetChildCount( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, actor.GetChildCount() ) );
+}
+
+/**
+ * Retrieve and child actor by index.
+ *
+ * @for Actor
+ * @method getChildAt
+ * @param {Integer} actor index
+ * @return {Object} actor on success, empty actor handle if not found
+ */
+void ActorApi::GetChildAt( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor parent = GetActor( isolate, args );
+  bool found( false );
+  int id = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Integer parameter missing" );
+    return;
+  }
+  Actor childActor = parent.GetChildAt( id );
+  if( childActor )
+  {
+    // wrap the child
+    v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, childActor );
+    args.GetReturnValue().Set( wrappedActor );
+  }
+}
+
+/**
+ * Search through this actor's hierarchy for an actor with the given name
+ * The actor itself is also considered in the search
+ *
+ * @for Actor
+ * @method findChildByName
+ * @param {String} actor name
+ * @return {Object} actor on success, empty actor handle if not found
+ */
+void ActorApi::FindChildByName( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor parent = GetActor( isolate, args );
+  bool found( false );
+  std::string name = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "string parameter missing" );
+    return;
+  }
+  Actor childActor = parent.FindChildByName( name );
+  if( childActor )
+  {
+    // wrap the child
+    v8::Handle < v8::Object > wrappedLayer = ActorWrapper::WrapActor( isolate, childActor );
+    args.GetReturnValue().Set( wrappedLayer );
+  }
+}
+
+/**
+ * Search through this actor's hierarchy for an actor with the given name or alias.
+ *
+ * Actors can customize this function to provide actors with preferred alias'
+ * For example 'previous' could return the last selected child.
+ * If no aliased actor is found then FindChildByName() is called.
+ *
+ * @for Actor
+ * @method findChildByAlias
+ * @param {String} actor alias
+ * @return {Object} actor on success, empty actor handle if not found
+ */
+void ActorApi::FindChildByAlias( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor parent = GetActor( isolate, args );
+  bool found( false );
+  std::string name = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "String parameter not found" );
+    return;
+  }
+  Actor childActor = parent.FindChildByAlias( name );
+  if( childActor )
+  {
+    // wrap the child
+    v8::Local < v8::Object > wrappedLayer = ActorWrapper::WrapActor( isolate, childActor );
+    args.GetReturnValue().Set( wrappedLayer );
+  }
+}
+
+/**
+ * Search through this actor's hierarchy for an actor with the given unique ID.
+ * The actor itself is also considered in the search
+ *
+ * @for Actor
+ * @method findChildById
+ * @param {Integer} id
+ * @return {Object} actor on success, empty actor handle if not found
+ */
+void ActorApi::FindChildById( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor parent = GetActor( isolate, args );
+
+  bool found( false );
+  int id = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Integer parameter missing" );
+    return;
+  }
+  Actor childActor = parent.FindChildById( id );
+  if( childActor )
+  {
+    // wrap the child
+    v8::Local < v8::Object > wrappedLayer = ActorWrapper::WrapActor( isolate, childActor );
+    args.GetReturnValue().Set( wrappedLayer );
+  }
+}
+
+
+/**
+ * retrieve the actor's parent.
+ *
+ * @for Actor
+ * @method getParent
+ * @return {Object} actor on success, empty actor handle if actor has no parent
+ */
+void ActorApi::GetParent( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+  Actor parent = actor.GetParent();
+
+  if( parent )
+  {
+    v8::Local < v8::Object > wrappedLayer = ActorWrapper::WrapActor( isolate, parent );
+    args.GetReturnValue().Set( wrappedLayer );
+  }
+}
+/**
+ * Converts screen coordinates into the actor's coordinate system using the default camera.
+ *
+ * The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
+ *
+ * @example
+ *    var local = actor.screenToLocal( [ 10, 53 ]);
+ *    var xPos = local.x;
+ *    var yPos = local.y;
+ *
+ *
+ * @for Actor
+ * @method screenToLocal
+ * @param {Object}  ScreenCoordinates array of 2 objects
+ * @return {Object} local coordinates object with x,y properties
+ */
+void ActorApi::ScreenToLocal( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  //ool ScreenToLocal(float& localX, float& localY, float screenX, float screenY) const;
+  bool found( false );
+
+  int argCount( args.Length() );
+  Vector2 vector;
+
+  if( argCount == 1 )
+  {
+    vector = V8Utils::GetVector2Parameter( PARAMETER_0, found, isolate, args );
+    if( !found )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid parameters (x,y)" );
+      return;
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid parameters (x,y)" );
+    return;
+  }
+  float localX, localY;
+  actor.ScreenToLocal( localX, localY, vector.x, vector.y );
+
+  v8::Local < v8::Object > localCoordinates = v8::Object::New( isolate );
+
+  localCoordinates->Set( v8::String::NewFromUtf8( isolate, "x" ), v8::Number::New( isolate, localX ) );
+  localCoordinates->Set( v8::String::NewFromUtf8( isolate, "y" ), v8::Number::New( isolate, localY ) );
+
+  args.GetReturnValue().Set( localCoordinates );
+
+}
+
+/**
+ * Sets whether the actor should be focusable by keyboard navigation.
+ *
+ * @for Actor
+ * @method setKeyboardFocusable
+ * @param {Boolean}  folcusable
+ */
+void ActorApi::SetKeyboardFocusable( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+  bool parameterFound( false );
+  bool focus = V8Utils::GetBooleanParameter( PARAMETER_0, parameterFound, isolate, args );
+  if( !parameterFound )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter missing" );
+    return;
+  }
+
+  actor.SetKeyboardFocusable( focus );
+}
+
+/**
+ * Returns whether the actor is focusable by keyboard navigation.
+ *
+ *
+ * @for Actor
+ * @method isKeyboardFocusable
+ * @return {Boolean}  folcusable
+ */
+void ActorApi::IsKeyboardFocusable( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, actor.IsKeyboardFocusable() ) );
+
+}
+/**
+ * retrieve the actor type
+ *
+ * @for Actor
+ * @method getActorType
+ * @return {String} Actor, ImageActor, TextActor, MeshActor, Layer, CameraActor ...
+ */
+void ActorApi::GetActorType( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  std::string name = actor.GetTypeName();
+  v8::Local < v8::String > v8String = v8::String::NewFromUtf8( isolate, name.c_str() );
+  args.GetReturnValue().Set( v8String );
+}
+/**
+ * Move an actor relative to its existing position.
+ * @example
+ *
+ *    // using an array
+ *    actor.moveBy( [20,40,0] );
+ *
+ * @for Actor
+ * @method moveBy
+ * @param {object} an array of 3 numbers
+ */
+void ActorApi::MoveBy( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  //Get displacement vector
+  Vector3 vector;
+  int argCount( args.Length() );
+  if( argCount == 1 )
+  {
+    bool found(false);
+    vector = V8Utils::GetVector3Parameter( PARAMETER_0, found, isolate, args );
+    if( !found )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "Vector3 move parameter missing" );
+      return;
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Vector3 move parameter missing" );
+    return;
+  }
+  actor.MoveBy( vector );
+
+}
+
+
+/**
+ * Apply a relative rotation to an actor.
+ * @example
+ *
+ *     var rotation =new dali.Rotation( pitch, roll, yaw );
+ *     actor.rotateBy( rotation );
+ *
+ * @for Actor
+ * @method rotateBy
+ * @param {object} dali rotation object
+ */
+void ActorApi::RotateBy( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  bool found( false );
+  Property::Value rotation = V8Utils::GetPropertyValueParameter( PARAMETER_0, found, isolate, args );
+
+  if( rotation.GetType() != Property::ROTATION )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Rotation parameter missing" );
+    return;
+  }
+  // the rotation parameter has to be either a AngleAxis or a Quaternion
+  // both will work when calling Get( Quaternion);
+
+  Quaternion quaternionValue;
+  rotation.Get( quaternionValue );
+
+  actor.RotateBy( quaternionValue );
+}
+
+/**
+ * Apply a relative scale to an actor.
+ * @example
+ *    // Double actor width and height ( keep depth the same )
+ *    // using an array
+ *    actor.scaleBy( [2,2,1] );
+ *
+ *
+ * @for Actor
+ * @method scaleBy
+ * @param {object} JavaScript array
+ */
+void ActorApi::ScaleBy( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  Vector3 vector;
+  int argCount( args.Length() );
+  if( argCount == 1 )
+  {
+    bool found(false);
+    vector = V8Utils::GetVector3Parameter( PARAMETER_0, found, isolate, args );
+    if( !found )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "Vector3 move parameter missing" );
+      return;
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Vector3 parameter missing" );
+    return;
+  }
+  actor.ScaleBy( vector );
+}
+/**
+ * Apply a relative scale to an actor.
+ * Actor opacity ranges from 0 (see through ) to 1 ( solid )
+ * @example
+ *    // reduce actor opactiy by a half
+ *    actor.opaictyBy(-0.5);
+ *
+ * @for Actor
+ * @method OpacityBy
+ * @param {float} relative opacity
+ */
+void ActorApi::OpacityBy( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  // void OpacityBy(float relativeOpacity);
+  bool found;
+  float opacity = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 0.f );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "float parameter missing" );
+    return;
+  }
+  actor.OpacityBy( opacity );
+}
+
+/**
+ * Apply a relative color change to an actor.
+ *
+ * @example
+ *    // increase actor red by half
+ *    actor.colorBy( [0.5, 0, 0, 0]);
+ *
+ *
+ * @for Actor
+ * @method colorBy
+ * @param {Object} Color JavaScript array
+ */
+void ActorApi::ColorBy( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Actor actor = GetActor( isolate, args );
+
+  bool found;
+  int argCount( args.Length() );
+  Vector4 color;
+
+  if( argCount == 1 )
+  {
+    color = V8Utils::GetVector4Parameter( PARAMETER_0, found, isolate, args );
+    if( !found )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "Vector4 parameter missing" );
+      return;
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Vector4 parameter missing" );
+    return;
+  }
+
+  actor.ColorBy( color );
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/actor-api.h b/plugins/dali-script-v8/src/actors/actor-api.h
new file mode 100644
index 0000000..38bc95a
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/actor-api.h
@@ -0,0 +1,85 @@
+#ifndef __DALI_V8PLUGIN_ACTOR_API_H__
+#define __DALI_V8PLUGIN_ACTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace TextViewApi
+{
+  /**
+   * Temporary TextView constructor
+   */
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+}
+
+namespace ActorApi
+{
+
+  /**
+   * constructor
+   */
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Actor API. See actor.h for description of functions
+   */
+  void IsRoot( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetId( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void OnStage( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsLayer( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetLayer( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void AddActor( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void RemoveActor( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void IsEqualTo( const v8::FunctionCallbackInfo& args );
+  void Unparent( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void GetChildAt( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void FindChildByName( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void FindChildByAlias( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void FindChildById( const v8::FunctionCallbackInfo< v8::Value >& args);
+  void GetParent( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetChildCount( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ScreenToLocal( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetKeyboardFocusable( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsKeyboardFocusable( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MoveBy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void RotateBy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ScaleBy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void OpacityBy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ColorBy( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  // new function just for JavaScript API, to help developers know what type of actor
+  // they're dealing with, returns actor name as a string
+  void GetActorType( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+}; // namespace ActorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_ACTOR_API_H__
diff --git a/plugins/dali-script-v8/src/actors/actor-wrapper.cpp b/plugins/dali-script-v8/src/actors/actor-wrapper.cpp
new file mode 100644
index 0000000..9ed0edb
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/actor-wrapper.cpp
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "actor-wrapper.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+v8::Persistent ActorWrapper::mActorTemplate;
+v8::Persistent ActorWrapper::mImageActorTemplate;
+v8::Persistent ActorWrapper::mTextActorTemplate;
+v8::Persistent ActorWrapper::mMeshActorTemplate;
+v8::Persistent ActorWrapper::mCameraActorTemplate;
+v8::Persistent ActorWrapper::mLayerActorTemplate;
+v8::Persistent ActorWrapper::mTextViewTemplate;
+
+namespace
+{
+
+
+/**
+ * pointer to a persistent template handle
+ */
+struct ActorTemplate
+{
+  v8::Persistent* actorTemplate;
+};
+
+/**
+ * array of templates for each type of actor
+ */
+const ActorTemplate ActorTemplateLookup[]=
+{
+    { &ActorWrapper::mActorTemplate },        // ACTOR
+    { &ActorWrapper::mImageActorTemplate },   // IMAGE_ACTOR
+    { &ActorWrapper::mTextActorTemplate  },   // TEXT_ACTOR
+    { &ActorWrapper::mMeshActorTemplate  },   // MESH_ACTOR
+    { &ActorWrapper::mLayerActorTemplate },   // LAYER_ACTOR
+    { &ActorWrapper::mCameraActorTemplate},   // CAMERA_ACTOR
+    { &ActorWrapper::mTextViewTemplate }
+};
+
+/**
+ * Bitmask of API's that an actor can support
+ */
+enum ActorApiBitMask
+{
+  ACTOR_API              = 1 << 0,
+  RENDERABLE_ACTOR_API   = 1 << 1,
+  IMAGE_ACTOR_API        = 1 << 2,
+  TEXT_ACTOR_API         = 1 << 3,
+  MESH_ACTOR_API         = 1 << 4,
+  LAYER_API              = 1 << 5,
+  CAMERA_ACTOR_API       = 1 << 6,
+};
+
+/**
+ * structure used for the ActorApiLookup.
+ */
+struct ActorApiStruct
+{
+  const char* actorName;
+  ActorWrapper::ActorType actorType;
+  Actor (*constructor)( const v8::FunctionCallbackInfo< v8::Value >& args);
+  int supportApis;
+};
+
+/**
+ * Lookup table to match a actor type with a constructor and supported API's.
+ */
+const ActorApiStruct ActorApiLookup[]=
+{
+  {"Actor",      ActorWrapper::ACTOR,        ActorApi::New,       ACTOR_API },
+  {"ImageActor", ActorWrapper::IMAGE_ACTOR,  ImageActorApi::New,  ACTOR_API | RENDERABLE_ACTOR_API | IMAGE_ACTOR_API   },
+  {"TextActor",  ActorWrapper::TEXT_ACTOR,   TextActorApi::New,   ACTOR_API | RENDERABLE_ACTOR_API | TEXT_ACTOR_API    },
+  {"MeshActor",  ActorWrapper::MESH_ACTOR,   MeshActorApi::New,   ACTOR_API | RENDERABLE_ACTOR_API | MESH_ACTOR_API    },
+  {"Layer",      ActorWrapper::LAYER_ACTOR,  LayerApi::New,       ACTOR_API | LAYER_API                                },
+  {"CameraActor",ActorWrapper::CAMERA_ACTOR, CameraActorApi::New, ACTOR_API | CAMERA_ACTOR_API                         },
+  {"TextView",   ActorWrapper::TEXT_VIEW,    TextViewApi::New,    ACTOR_API },
+
+};
+
+const unsigned int ActorApiLookupCount = sizeof(ActorApiLookup)/sizeof(ActorApiLookup[0]);
+
+
+
+/**
+ * Creates an actor given a type name
+ * Uses the type registry to create an actor of the correct type
+ */
+Actor CreateActor( const v8::FunctionCallbackInfo< v8::Value >& args,
+                        const std::string& typeName )
+{
+  Actor actor;
+
+  ActorWrapper::ActorType actorType = ActorWrapper::GetActorType( typeName );
+
+  // if we don't currently support the actor type, then use type registry to create it
+  if( actorType == ActorWrapper::UNKNOWN_ACTOR )
+  {
+    Dali::TypeInfo typeInfo = Dali::TypeRegistry::Get().GetTypeInfo( typeName );
+    if( typeInfo ) // handle, check if it has a value
+    {
+      Dali::BaseHandle handle = typeInfo.CreateInstance();
+      if( handle )
+      {
+        actor = Actor::DownCast( handle );
+      }
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION(args.GetIsolate(),"Unknown actor type");
+      return Actor();
+    }
+  }
+  else
+  {
+    // run the constructor for this type of actor so it can pull out
+    // custom parameters, e.g. new TextActor("hello world"); or ImageActor( MyImage );
+    actor = (ActorApiLookup[actorType].constructor)( args );
+  }
+  return actor;
+}
+
+
+
+/**
+ * given an actor type return what api's it supports
+ */
+int GetActorSupportedApis( ActorWrapper::ActorType type )
+{
+  return ActorApiLookup[ type].supportApis;
+}
+
+/**
+ * Used for the ActorFunctionTable to map function names to functions
+ * with for a specific API
+ */
+struct ActorFunctions
+{
+  const char* name;               ///< function name
+  void (*function)( const v8::FunctionCallbackInfo< v8::Value >& args);
+  ActorApiBitMask api;
+};
+
+/**
+ * Contains a list of all functions that can be called an
+ * actor / image-actor / mesh-actor/ layer / camera-actor
+ */
+const ActorFunctions ActorFunctionTable[]=
+{
+    /**************************************
+    * Actor API (in order of actor.h)
+    * Any properties that have accessor functions are ignored to avoid duplication
+    **************************************/
+    // ignore. GetName()  use Actor.name
+    // ignore. SetName()  use Actor.name
+    { "GetId",             ActorApi::GetId,            ACTOR_API },
+    { "IsRoot",            ActorApi::IsRoot,           ACTOR_API },
+    { "OnStage",           ActorApi::OnStage,          ACTOR_API },
+    { "IsLayer",           ActorApi::IsLayer,          ACTOR_API },
+    { "GetLayer",          ActorApi::GetLayer,         ACTOR_API },
+    { "Add",               ActorApi::AddActor,         ACTOR_API },
+    { "Remove",            ActorApi::RemoveActor,      ACTOR_API },
+    { "IsEqualTo" ,        ActorApi::IsEqualTo,        ACTOR_API },
+    { "Unparent",          ActorApi::Unparent,         ACTOR_API },
+    { "GetChildCount",     ActorApi::GetChildCount,    ACTOR_API },
+    { "GetChildAt"   ,     ActorApi::GetChildAt,       ACTOR_API },
+    { "FindChildByName",   ActorApi::FindChildByName,  ACTOR_API },
+    { "FindChildByAlias",  ActorApi::FindChildByAlias, ACTOR_API },
+    { "FindChildById",     ActorApi::FindChildById,    ACTOR_API },
+    { "GetParent" ,        ActorApi::GetParent,        ACTOR_API },
+    { "GetActorType" ,     ActorApi::GetActorType,     ACTOR_API }, // custom for javascript
+
+    // ignore. SetParentOrigin() use Actor.parentOrigin
+    // ignore. GetCurrentParentOrigin()  use Actor.parentOrigin
+    // ignore. SetAnchorPoint()  use Actor.anchorPoint
+    // ignore. GetCurrentAnchorPoint()  use Actor.anchorPoint
+    // ignore. SetSize() use Actor.size
+    // ignore. GetCurrentSize() use Actor.size
+    // ignore. SetPosition(....) use Actor.position
+    // ignore. SetX, SetY, SetZ,  use Actor.position.x, Actor.position.y, Actor.position.z
+    { "MoveBy",         ActorApi::MoveBy,              ACTOR_API },
+    // ignore GetCurrentPosition(). use Actor.position
+    // ignore GetCurrentWorldPosition() use Actor.worldPosition
+    // ignore SetPositionInheritanceMode() use Actor.positionInheritance
+    // ignore GetPositionInheritanceMode()  use Actor.positionInheritance
+    // ignore SetRotation() use Actor.rotation
+    { "RotateBy",         ActorApi::RotateBy,          ACTOR_API },
+    // ignore GetCurrentRotation() use Actor.rotation
+    // ignore SetInheritRotation() use Actor.inheritRotation
+    // ignore IsRotationInherited() use Actor.inheritRotation
+    // ignore GetCurrentWorldRotation() use Actor.worldRotation
+    // ignore SetScale() use Actor.scale
+    { "ScaleBy",         ActorApi::ScaleBy,            ACTOR_API },
+    // ignore GetCurrentScale() use Actor.scale
+    // ignore GetCurrentWorldScale() use Actor.worldScale
+    // ignore SetInheritScale() use Actor.inheritScale
+    // ignore IsScaleInherited() use Actor.inheritScale
+    // ignore GetCurrentWorldMatrix() use Actor.worldMatrix
+    // ignore SetVisible() use Actor.visible
+    // ignore IsVisible() use Actor.visible
+    // ignore SetOpacity() use Actor.opacity
+    { "OpactiyBy",         ActorApi::OpacityBy,        ACTOR_API },
+    // ignore GetCurrentOpacity() use Actor.opacity
+    // ignore SetColor() use Actor.color
+    { "ColorBy",         ActorApi::ColorBy,            ACTOR_API },
+    // ignore GetCurrentColor() use Actor.color
+    // ignore SetColorMode() use Actor.colorMode
+    // ignore GetColorMode() use Actor.colorMode
+    // ignore GetCurrentWorldColor() use Actor.worldColor
+    // ignore SetInheritShaderEffect() use Actor.inheritShaderEffect
+    // ignore GetInheritShaderEffect() use Actor.inheritShaderEffect
+    // ignore SetDrawMode() use Actor.drawMode
+    // ignore GetDrawMode() use Actor.drawMode
+    // ignore SetSensitive() use Actor.sensitve
+    // ignore IsSensitive() use Actor.sensitive
+    { "ScreenToLocal"       , ActorApi::ScreenToLocal,         ACTOR_API},
+    // ignore SetLeaveRequired() use Actor.leaveRequired
+    // ignore GetLeaveRequired() use Actor.leaveRequired
+    { "SetKeyboardFocusable", ActorApi::SetKeyboardFocusable,  ACTOR_API }, //-- should this be a property???
+    { "IsKeyboardFocusable" , ActorApi::IsKeyboardFocusable,   ACTOR_API }, //-- should this be a property???
+
+    /**************************************
+     * Renderable Actor API (in order of renderable-actor.h)
+     **************************************/
+    { "SetSortModifier",    RenderableActorApi::SetSortModifier,   RENDERABLE_ACTOR_API  },
+    { "GetSortModifier",    RenderableActorApi::GetSortModifier,   RENDERABLE_ACTOR_API  },
+    { "SetCullFace",        RenderableActorApi::SetCullFace,       RENDERABLE_ACTOR_API  },
+    { "GetCullFace",        RenderableActorApi::GetCullFace,       RENDERABLE_ACTOR_API  },
+    { "SetBlendMode",       RenderableActorApi::SetBlendMode,      RENDERABLE_ACTOR_API  },
+    { "GetBlendMode",       RenderableActorApi::GetBlendMode,      RENDERABLE_ACTOR_API  },
+    { "SetBlendFunc",       RenderableActorApi::SetBlendFunc,      RENDERABLE_ACTOR_API  },
+    { "GetBlendFunc",       RenderableActorApi::GetBlendFunc,      RENDERABLE_ACTOR_API  },
+    { "SetBlendEquation",   RenderableActorApi::SetBlendEquation,  RENDERABLE_ACTOR_API  },
+    { "GetBlendEquation",   RenderableActorApi::GetBlendEquation,  RENDERABLE_ACTOR_API  },
+    { "SetBlendColor",      RenderableActorApi::SetBlendColor,     RENDERABLE_ACTOR_API  },
+    { "GetBlendColor",      RenderableActorApi::GetBlendColor,     RENDERABLE_ACTOR_API  },
+    { "SetShaderEffect",    RenderableActorApi::SetShaderEffect,   RENDERABLE_ACTOR_API  },
+    { "GetShaderEffect",    RenderableActorApi::GetShaderEffect,   RENDERABLE_ACTOR_API  },
+    { "RemoveShaderEffect", RenderableActorApi::RemoveShaderEffect,RENDERABLE_ACTOR_API  },
+
+
+
+
+    /**************************************
+     * Layer  API (in order of layer.h)
+     **************************************/
+    { "GetDepth",           LayerApi::GetDepth,                 LAYER_API  },
+    { "Raise",              LayerApi::Raise,                    LAYER_API  },
+    { "Lower",              LayerApi::Lower,                    LAYER_API  },
+    { "RaiseAbove",         LayerApi::RaiseAbove,               LAYER_API  },
+    { "RaiseBelow",         LayerApi::LowerBelow,               LAYER_API  },
+    { "RaiseToTop",         LayerApi::RaiseToTop,               LAYER_API  },
+    { "LowerToBottom",      LayerApi::ToBottom,                 LAYER_API  },
+    { "MoveAbove",          LayerApi::MoveAbove,                LAYER_API  },
+    { "MoveBelow",          LayerApi::MoveBelow,                LAYER_API  },
+    // ignore SetClipping, use layer.clippingEnable
+    // ignore IsClipping, use layer.clippingEnable
+    // ignore SetClippingBox, use layer.clippingBox
+    { "SetDepthTestDisabled", LayerApi::SetDepthTestDisabled,   LAYER_API },
+    { "IsDepthTestDisabled",  LayerApi::IsDepthTestDisabled,    LAYER_API },
+    // @todo SetSortFunction
+
+    /**************************************
+     * Image Actor API (in order of image-actor.h)
+     **************************************/
+
+    { "SetImage",           ImageActorApi::SetImage,              IMAGE_ACTOR_API },
+    { "GetImage",           ImageActorApi::GetImage,              IMAGE_ACTOR_API },
+    { "SetToNaturalSize",   ImageActorApi::SetToNaturalSize,      IMAGE_ACTOR_API },
+    // ignore SetPixelArea, use imageActor.pixelArea
+    // ignore GetPixelArea, use imageActor.pixelArea
+    { "IsPixelAreaSet",     ImageActorApi::IsPixelAreaSet,        IMAGE_ACTOR_API },
+    { "ClearPixelArea",     ImageActorApi::ClearPixelArea,        IMAGE_ACTOR_API },
+    // ignore SetStyle, use imageActor.style
+    // ignore GetStyle, use imageActor.style
+    // ignore SetNinePatchBorder use imageActor.border
+    // ignore GetNinePatchBorder use imageActor.border
+    // ignore SetFadeIn use imageActor.fadeIn
+    // ignore GetFadeIn use imageActor.fadeIn
+    // ignore SetFadeInDuration use imageActor.fadeInDuration
+    // ignore GetFadeInDuration use imageActor.fadeInDuration
+    //{ "GetCurrentImageSize", ImageActorApi::GetCurrentImageSize,  IMAGE_ACTOR_API },
+
+
+    /**************************************
+     * Text Actor API (in order of text-actor.h)
+     **************************************/
+    //ignore SetText use textActor.text
+    { "SetToNaturalSize",   TextActorApi::SetToNaturalSize,      TEXT_ACTOR_API },
+    // ignore GetFont use textActor.font
+    // ignore SetFont use textActor.font
+    // ignore SetGradient use textActor.gradientColor
+    // ignore GetGradient textActor.gradientColor
+    // ignore SetGradientStartPoint use textActor.gradientStartPoint
+    // ignore GetGradientStartPoint textActor.gradientStartPoint
+    // ignore SetGradientEndPoint use textActor.gradientEndPoint
+    // ignore GetGradientEndPoint textActor.gradientEndPoint
+    // @todo? SetTextStyle ( can use individual properties as a work around )
+    // @todo? GetTextStyle ( can use individual properties as a work around )
+    // ignore SetTextColor use textActor.textColor
+    // ignore GetTextColor use textActor.textColor
+    // ignore SetSmoothEdge use textActor.smoothEdge
+    // ignore SetOutline use textActor.outLineEnable, outlineColor, thicknessWidth
+    // ignore SetGlow use textActor.glowEnable, glowColor, glowIntensity
+    // ignore SetShadow use textActor.shadowEnable, shadowColor, shadowOffset, shadowSize
+    // ignore SetItalics use textActor.italicsAngle ?
+    // ignore GetItalics  @todo add italics flag? or just stick with angle
+    // ignore GetItalicsAngle  use textActor.italicsAngle
+    // ignore SetUnderline use textActor.underline
+    // ignore GetUnderline use textActor.underline
+    // ignore SetWeight use textActor.weight
+    // ignore GetWeight use textActor.weight
+    // ignore SetFontDetectionAutomatic use textActor.fontDetectionAutomatic
+    // ignore IsFontDetectionAutomatic use textActor.fontDetectionAutomatic
+    // ignore GetLoadingState text is loaded synchronously
+    // ignore TextAvailableSignal text is loaded synchronously
+
+    /**************************************
+     * Mesh Actor API (in order of mesh-actor.h)
+     **************************************/
+    // @todo a version of MeshActor::New( mesh )
+    // @todo a version of MeshActor::New( AnimatableMesh )
+    // @todo SetMaterial
+    // @todo GetMaterial
+    // SetAffectedByLighting  should be a property really
+    { "SetAffectedByLighting", MeshActorApi::SetAffectedByLighting, MESH_ACTOR_API },
+    { "IsAffectedByLighting",  MeshActorApi::IsAffectedByLighting,  MESH_ACTOR_API },
+    // @todo BindBonesToMesh
+
+    /**************************************
+     * Camera Actor API (in order of camera.h)
+     **************************************/
+    // ignore SetType use camera.type
+    // ignore GetType use camera.type
+    // ignore SetProjectionMode use camera.projectionMode
+    // ignore GetProjectionMode use camera.projectionMode
+    // ignore SetFieldOfView use camera.fieldOfView
+    // ignore GetFieldOfView use camera.fieldOfView
+    // ignore SetAspectRatio use camera.aspectRatio
+    // ignore GetAspectRatio use camera.aspectRatio
+    // ignore SetNearClippingPlane use camera.nearPlaneDistance
+    // ignore GetNearClippingPlane use camera.nearPlaneDistance
+    // ignore SetFarClippingPlane use camera.farPlaneDistance
+    // ignore GetFarClippingPlane use camera.farPlaneDistance
+    // ignore GetTargetPosition use camera.targetPosition
+    // ignore SetInvertYAxis use camera.invertYAxis
+    // ignore GetInvertYAxis use camera.invertYAxis
+    { "SetPerspectiveProjection",   CameraActorApi::SetPerspectiveProjection,   CAMERA_ACTOR_API },
+    { "SetOrthographicProjection",  CameraActorApi::SetOrthographicProjection,  CAMERA_ACTOR_API },
+
+};
+
+const unsigned int ActorFunctionTableCount = sizeof(ActorFunctionTable)/sizeof(ActorFunctionTable[0]);
+} //un-named space
+
+
+ActorWrapper::ActorWrapper( Actor actor,
+              GarbageCollectorInterface& gc )
+: HandleWrapper( BaseWrappedObject::ACTOR , actor, gc ),
+  mActor( actor )
+
+{
+}
+
+v8::Handle ActorWrapper::WrapActor(v8::Isolate* isolate, Actor actor )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local object = WrapActor( isolate, actor, GetActorType( actor.GetTypeName() ) );
+
+  return handleScope.Escape( object );
+}
+
+Actor ActorWrapper::GetActor()
+{
+  return mActor;
+}
+
+v8::Handle ActorWrapper::WrapActor( v8::Isolate* isolate, Actor actor, ActorType actorType )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetActorTemplate( isolate, actorType );
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create teh actor object
+  ActorWrapper* pointer = new ActorWrapper( actor, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  // This also stores Dali object, in an internal field inside the JavaScript object.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local ActorWrapper::GetActorTemplate( v8::Isolate* isolate, ActorWrapper::ActorType type )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  if( ActorTemplateLookup[type].actorTemplate->IsEmpty() )
+  {
+    objectTemplate = MakeDaliActorTemplate( isolate, type );
+    ActorTemplateLookup[type].actorTemplate->Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, *ActorTemplateLookup[type].actorTemplate );
+  }
+
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle ActorWrapper::MakeDaliActorTemplate( v8::Isolate* isolate, ActorType actorType )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // find out what API's this actor supports
+  int supportApis = GetActorSupportedApis( actorType );
+
+  // add our function properties
+  for( unsigned int i = 0; i < ActorFunctionTableCount; ++i )
+  {
+    const ActorFunctions property =  ActorFunctionTable[i];
+
+    // check to see if the actor supports a certain type of API
+    // e.g. ImageActor will support ACTOR_API, RENDERABLE_API and IMAGE_ACTOR_API
+    if( supportApis &  property.api )
+    {
+      std::string funcName = V8Utils::GetJavaScriptFunctionName( property.name);
+
+      objTemplate->Set( v8::String::NewFromUtf8(   isolate, funcName.c_str() ),
+                      v8::FunctionTemplate::New( isolate, property.function ) );
+    }
+  }
+
+  // property handle intercepts property getters and setters and signals
+  HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
+
+
+  return handleScope.Escape( objTemplate );
+}
+
+void ActorWrapper::NewActor( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  if( !args.IsConstructCall() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "constructor called without 'new" );
+    return;
+  }
+
+  // find out the callee function name...e.g. TextActor, ImageActor, MeshActor
+  v8::Local callee = args.Callee();
+  v8::Local v8String = callee->GetName();
+  std::string typeName = V8Utils::v8StringToStdString( v8String );
+
+  // create a new actor based on type, using the type registry.
+  Actor actor = CreateActor( args, typeName );
+
+  v8::Local localObject = WrapActor( isolate, actor );
+
+  args.GetReturnValue().Set( localObject );
+}
+
+/**
+ * given an actor type name, e.g. ImageActor returns the type, e.g. ActorWrapper::IMAGE_ACTOR
+ */
+ActorWrapper::ActorType ActorWrapper::GetActorType( const std::string& name )
+{
+  for( unsigned int i = 0 ; i < ActorApiLookupCount ; i++ )
+  {
+    if( ActorApiLookup[i].actorName == name )
+    {
+      return ActorApiLookup[i].actorType;
+    }
+  }
+  return ActorWrapper::UNKNOWN_ACTOR;
+}
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/actor-wrapper.h b/plugins/dali-script-v8/src/actors/actor-wrapper.h
new file mode 100644
index 0000000..79381ba
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/actor-wrapper.h
@@ -0,0 +1,131 @@
+#ifndef __DALI_V8PLUGIN_ACTOR_WRAPPER_H__
+#define __DALI_V8PLUGIN_ACTOR_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * Wraps a Dali Actor.
+ */
+class ActorWrapper : public HandleWrapper
+{
+
+public:
+
+  /**
+   * Actor type used an index
+   */
+  enum ActorType
+  {
+    UNKNOWN_ACTOR = -1,
+    ACTOR       = 0,
+    IMAGE_ACTOR  =1,
+    TEXT_ACTOR   =2,
+    MESH_ACTOR   =3,
+    LAYER_ACTOR  =4,
+    CAMERA_ACTOR =5,
+    LIGHT_ACTOR  =6,
+    TEXT_VIEW    =7
+  };
+
+  /**
+   * Constructor
+   * @param actor DALi actor
+   * @param gc garbage collection interface
+   */
+  ActorWrapper( Actor actor,
+                GarbageCollectorInterface& gc );
+
+  /**
+   * destructor
+   */
+  virtual ~ActorWrapper()
+  {
+  }
+
+  /**
+   * @brief Creates a new Actor wrapped inside a Javascript Object.
+   * @note: the actor type ie 'ImageActor' is expected to be the name of the callee function.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewActor( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * @brief Wraps an actor of a given type
+   */
+  static v8::Handle WrapActor(v8::Isolate* isolate, Dali::Actor actor,ActorType actorType);
+
+  /**
+   * @brief Wraps an actor, the type is looked up from the actor
+   */
+  static v8::Handle WrapActor(v8::Isolate* isolate, Dali::Actor actor );
+
+  // The Actor ObjectTemplates.
+  static v8::Persistent mActorTemplate;
+  static v8::Persistent mImageActorTemplate;
+  static v8::Persistent mTextActorTemplate;
+  static v8::Persistent mMeshActorTemplate;
+  static v8::Persistent mCameraActorTemplate;
+  static v8::Persistent mLayerActorTemplate;
+  static v8::Persistent mTextViewTemplate;
+
+  /**
+   * @return the wrapped actor
+   */
+  Actor GetActor();
+
+  /**
+   * @return they actor type
+   */
+  static ActorWrapper::ActorType GetActorType( const std::string& name );
+
+private:
+
+  /**
+   * Helper to make the actor template
+   *
+   */
+  static v8::Handle MakeDaliActorTemplate( v8::Isolate* isolate, ActorType actorType );
+
+  /**
+   * Helper, get an actor template given an actor type
+   */
+  static v8::Local GetActorTemplate( v8::Isolate* isolate, ActorType type );
+
+  Actor mActor;
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/actors/camera-actor-api.cpp b/plugins/dali-script-v8/src/actors/camera-actor-api.cpp
new file mode 100644
index 0000000..94fcbe5
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/camera-actor-api.cpp
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "camera-actor-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un-named namespace
+{
+
+CameraActor GetCameraActor( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return CameraActor::DownCast( handleWrapper->mHandle );
+}
+
+} // un-named name space
+
+/***************************************
+ * CAMERA ACTOR FUNCTIONS
+ ****************************************/
+/**
+ * Constructor
+ *
+ * @constructor
+ * @method CameraActor
+ * @for CameraActor
+ * @return {Object} CameraActor
+ */
+Actor CameraActorApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  return CameraActor::New();
+}
+
+/**
+ *
+ * Sets the default camera perspective projection for the given canvas size.
+ *
+ * Sets the near and far clipping planes, the field of view, the aspect ratio
+ * and the Z position of the actor based on the canvas size so that 1 unit in
+ * XY (z=0) plane is 1 pixel on screen.
+ *
+ * If the canvas size is ZERO, it sets the default camera perspective
+ * projection for the stage's size.
+ *
+ * If size is non ZERO, \e width and \e height must be greater than zero.
+ *
+ *
+ * @example
+ *     var camera = dali.stage.getRenderTaskList().getTask(0).getCameraActor();
+ *
+ *     camera.setPerspectiveProjection( [100, 150] );
+ *
+ *
+ * @for CameraActor
+ * @method setPerspectiveProjection
+ * @param {Object}  The canvas size, array of 2 numbers
+ */
+void CameraActorApi::SetPerspectiveProjection( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  CameraActor cameraActor = GetCameraActor( isolate, args );
+
+  bool found;
+  Vector2 size = V8Utils::GetVector2Parameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+  cameraActor.SetPerspectiveProjection( size );
+}
+
+/**
+ *
+ * Sets the camera projection to use orthographic projection.
+ *
+ * The XY plane is centered on the camera axis. The units in the X/Y
+ * plane directly equate to pixels on an equivalently sized
+ * framebuffer.
+ *
+ * The Z position of the actor, and the near and far clip planes of the
+ * bounding box match those that would be created by using
+ * SetPerspectiveProjection with the same size.
+ *
+ *
+ * @example
+ *     var camera = dali.stage.getRenderTaskList().getTask(0).getCameraActor();
+ *     camera.setOrthographicProjection( [1920, 1080] );
+ *
+ * @for CameraActor
+ * @method setOrthographicProjection
+ * @param {Object}  Size Size of XY plane (normal to camera axis)
+ */
+void CameraActorApi::SetOrthographicProjection( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  CameraActor cameraActor = GetCameraActor( isolate, args );
+
+  bool found;
+  Vector2 size = V8Utils::GetVector2Parameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+  cameraActor.SetOrthographicProjection( size );
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/camera-actor-api.h b/plugins/dali-script-v8/src/actors/camera-actor-api.h
new file mode 100644
index 0000000..df250f4
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/camera-actor-api.h
@@ -0,0 +1,51 @@
+#ifndef __DALI_V8PLUGIN_CAMERA_ACTOR_API_H__
+#define __DALI_V8PLUGIN_CAMERA_ACTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace CameraActorApi
+{
+  /**
+   * constructor
+   */
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Camera API see DALI camera.h
+   */
+  void SetPerspectiveProjection( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetOrthographicProjection( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace CameraActorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_CAMERA_ACTOR_API_H__
diff --git a/plugins/dali-script-v8/src/actors/image-actor-api.cpp b/plugins/dali-script-v8/src/actors/image-actor-api.cpp
new file mode 100644
index 0000000..fa93c7f
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/image-actor-api.cpp
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "image-actor-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace //unnamed name space
+{
+
+ImageActor GetImageActor( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return ImageActor::DownCast( handleWrapper->mHandle );
+}
+
+} //unnamed name space
+
+/**
+ * Constructor
+ *
+ * @constructor
+ * @method ImageActor
+ * @for ImageActor
+ * @param {Object} [image] Image object
+ * @param {Object} [pixelArea] Vector4
+ * @return {Object} ImageActor
+ * @example
+ *    new DALI.imageActor( image, [10,23,35,56] );
+ */
+Actor ImageActorApi::New( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  // Image actor has 3 different constructors
+  // New();
+  // New( image);
+  // New( image, PixelArea pixelArea);
+
+  if( args.Length() == 0 )
+  {
+    return ImageActor::New();
+  }
+
+  // args.Length> 0, must have an Image parameter
+  bool found( false );
+  Image image = V8Utils::GetImageParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing image from param 0" );
+    return ImageActor();
+  }
+
+  // check for PixelArea, accept a DALI Vector4 object ( which can be a JavaScript array)
+  // e.g.  new DALI.imageActor( image, [10,23,35,56] );
+  // or    new DALI.imageActor( image, Vector4 );
+
+  if( args.Length() > 1 )
+  {
+    Vector4 rect = V8Utils::GetVector4Parameter( PARAMETER_1, found, isolate, args );
+    if( !found )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, " bad parameters" );
+      return ImageActor();
+    }
+    Rectrectangle( static_cast(rect.x),
+                        static_cast(rect.y),
+                        static_cast(rect.z),
+                        static_cast(rect.w));
+
+    return ImageActor::New( image, rectangle );
+  }
+  else
+  {
+    return ImageActor::New( image );
+  }
+}
+
+/**
+ * Set the image rendered by the actor.
+ *
+ * When the image is loaded the actor's size will be reset to the image size,
+ * unless a custom size was chosen, e.g. via actor.size or a pixel area
+ * was set.
+ * Note: The old image will continue to be displayed until the given image has loaded.
+ * @for ImageActor
+ * @method setImage
+ * @param {Object} image The image to display.
+ *
+ */
+void ImageActorApi::SetImage( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  Image image = V8Utils::GetImageParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameters" );
+    return;
+  }
+  ImageActor imageActor = GetImageActor( isolate, args );
+  imageActor.SetImage( image );
+}
+
+/**
+ * brief Retrieve the image rendered by the actor's attachment.
+ * @for ImageActor
+ * @method getImage
+ * @return {Object} the image.
+ */
+void ImageActorApi::GetImage( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageActor imageActor = GetImageActor( isolate, args );
+  Image image = imageActor.GetImage();
+
+  // wrap the image
+  v8::Local localObject = ImageWrapper::WrapImage( isolate, image );
+  args.GetReturnValue().Set( localObject );
+}
+
+/**
+ * Tell the image actor to use the natural size of the current image
+ * or future images.
+ *
+ * Calling SetSize on this actor or animating the size of the actor
+ * overrides this behaviour.
+ *
+ * The image actor uses the natural image size after an image
+ * has been loaded.
+ * @for ImageActor
+ * @method setToNaturalSize
+ */
+void ImageActorApi::SetToNaturalSize( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageActor imageActor = GetImageActor( isolate, args );
+
+  imageActor.SetToNaturalSize();
+
+}
+
+/**
+ * Query whether a pixel area has been set.
+ * @for ImageActor
+ * @method isPixelAreaSet
+ * @return {Boolean} True if a pixel area has been set.
+ */
+void ImageActorApi::IsPixelAreaSet( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageActor imageActor = GetImageActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, imageActor.IsPixelAreaSet() ) );
+}
+
+/**
+ * Remove any pixel areas specified with SetPixelArea; the entire image will be displayed.
+ *
+ * The actor size will change to that of the Image unless a custom size was set, e.g. via
+ * actor.size
+ * @for ImageActor
+ * @method clearPixelArea
+ */
+void ImageActorApi::ClearPixelArea( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageActor imageActor = GetImageActor( isolate, args );
+
+  imageActor.ClearPixelArea();
+}
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/image-actor-api.h b/plugins/dali-script-v8/src/actors/image-actor-api.h
new file mode 100644
index 0000000..3c75cf6
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/image-actor-api.h
@@ -0,0 +1,54 @@
+#ifndef __DALI_V8PLUGIN_IMAGE_ACTOR_API_H__
+#define __DALI_V8PLUGIN_IMAGE_ACTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ImageActorApi
+{
+
+  /**
+   * constructor
+   */
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * ImageActorApi API see image-actor.h for a description
+   * Most of the API is covered by the property system
+   */
+  void SetImage( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetImage( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetToNaturalSize( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsPixelAreaSet( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ClearPixelArea( const v8::FunctionCallbackInfo< v8::Value >& args );
+}; // namespace ImageActorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_IMAGE_ACTOR_API_H__
diff --git a/plugins/dali-script-v8/src/actors/layer-api.cpp b/plugins/dali-script-v8/src/actors/layer-api.cpp
new file mode 100644
index 0000000..734efef
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/layer-api.cpp
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "layer-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace //unnamed name space
+{
+
+Layer GetLayer( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return Layer::DownCast( handleWrapper->mHandle );
+}
+
+} //unnamed name space
+
+/***************************************
+ * LAYER FUNCTIONS
+ *
+ ****************************************/
+/**
+ * Constructor
+ *
+ * @constructor
+ * @method Layer
+ * @for Layer
+ * @return {Object} Layer
+ */
+Actor LayerApi::New( const v8::FunctionCallbackInfo& args )
+{
+  return Layer::New();
+}
+
+/**
+ *  Query the depth of the layer
+ *
+ * 0 is bottom most layer, higher number is on top
+ * Condition: layer is on the stage
+ * If layer is not added to the stage, returns 0.
+ * @return  {Number}  the current depth of the layer.
+ */
+void LayerApi::GetDepth( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, layer.GetDepth() ) );
+
+}
+
+/**
+ * Increment the depth of the layer.
+ * Condition: layer is on the stage
+ * @method Raise
+ * @for Layer
+ *
+ */
+void LayerApi::Raise( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  layer.Raise();
+}
+
+/**
+ * Decrement the depth of the layer.
+ * Condition: layer is on the stage
+ * @for Layer
+ * @method lower
+ */
+void LayerApi::Lower( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  layer.Lower();
+}
+
+/**
+ *  Ensures the layers depth is greater than the target layer.
+ *
+ * If the layer already is above target layer its depth is not changed
+ * If the layer was below target, its new depth will be immediately above target
+ * Note! All layers between this layer and target get new depth values
+ * Condition: layer is on the stage
+ * Condition: target layer is on the stage
+ * @for Layer
+ * @method raiseAbove
+ * @param target layer to get above of
+ */
+void LayerApi::RaiseAbove( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  bool found(false);
+
+  Layer target = V8Utils::GetLayerParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    layer.RaiseAbove( target );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "layer param not found");
+  }
+}
+
+/**
+ *  Ensures the layers depth is less than the target layer.
+ *
+ * If the layer already is below the layer its depth is not changed
+ * If the layer was above target, its new depth will be immediately below target
+ * Note! All layers between this layer and target get new depth values
+ * Conditions: layer is on the stage, target layer is on the stage
+ * @param target layer to get below of
+ * @for Layer
+ * @method lowerBelow
+ */
+void LayerApi::LowerBelow( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  bool found( false );
+
+  Layer target = V8Utils::GetLayerParameter( PARAMETER_0, found, isolate, args );
+
+  if( found )
+  {
+    layer.LowerBelow( target );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "layer param not found");
+  }
+
+}
+
+/**
+ * Raises the layer to the top.
+ * Conditions:  layer is on the stage
+ * @for Layer
+ * @method raiseToTop
+ */
+void LayerApi::RaiseToTop( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  layer.RaiseToTop();
+}
+
+/**
+ * Lowers the layer to the bottom.
+ * Conditions:  layer is on the stage
+ * @for Layer
+ * @method lowerToBottom
+ */
+void LayerApi::ToBottom( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  layer.LowerToBottom();
+}
+
+/**
+ *  Moves the layer directly above the given layer.
+ *
+ * After the call this layers depth will be immediately above target
+ * Note! All layers between this layer and target get new depth values
+ * Conditions: layer is on the stage, target layer is on the stage
+ * @param target layer to get on top of
+ * @for Layer
+ * @method moveAbove
+ */
+void LayerApi::MoveAbove( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  bool found( false );
+
+  Layer target = V8Utils::GetLayerParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    layer.MoveAbove( target );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "layer param not found");
+  }
+}
+
+/**
+ *  Moves the layer directly below the given layer.
+ *
+ * After the call this layers depth will be immediately below target
+ * Note! All layers between this layer and target get new depth values
+ * Condition: layer is on the stage
+ * Condition: target layer is on the stage
+ * @param target layer to get below of
+ * @for Layer
+ * @method moveBelow
+ */
+void LayerApi::MoveBelow( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  bool found( false );
+
+  Layer target = V8Utils::GetLayerParameter( PARAMETER_0, found, isolate, args );
+
+  if( found )
+  {
+    layer.MoveBelow( target );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "layer param not found");
+  }
+}
+
+// should really be a property
+/**
+ *  Whether to disable the depth test.
+ *
+ * By default a layer enables depth test if there is more than one opaque actor or if there is one opaque actor and one, or more, transparent actors.
+ * However, it's possible to disable the depth test by calling this method.
+ *
+ * @param {Boolean}  disable true disables depth test. false sets the default behaviour.
+ * @for Layer
+ * @method setDepthTestDisabled
+ */
+void LayerApi::SetDepthTestDisabled( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  bool parameterFound( false );
+  bool depthTest = V8Utils::GetBooleanParameter( PARAMETER_0, parameterFound, isolate, args );
+  if( !parameterFound )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+  layer.SetDepthTestDisabled( depthTest );
+
+}
+
+/**
+ *  Retrieves whether depth test is disabled.
+ *
+ * @return { Boolean}  true if depth test is disabled.
+ * @for Layer
+ * @method isDepthTestDisabled
+ */
+void LayerApi::IsDepthTestDisabled( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Layer layer = GetLayer( isolate, args );
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, layer.IsDepthTestDisabled() ) );
+}
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/layer-api.h b/plugins/dali-script-v8/src/actors/layer-api.h
new file mode 100644
index 0000000..9667452
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/layer-api.h
@@ -0,0 +1,60 @@
+#ifndef __DALI_V8PLUGIN_LAYER_API_H__
+#define __DALI_V8PLUGIN_LAYER_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace LayerApi
+{
+  /**
+   * Layer constructor
+   */
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Layer API see layer.h for a description
+   */
+  void GetDepth( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Raise( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Lower( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void RaiseAbove( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void LowerBelow( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void RaiseToTop( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ToBottom( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MoveBelow( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MoveAbove( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetDepthTestDisabled( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsDepthTestDisabled( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+}; // namespace LayerApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_LAYER_API_H__
diff --git a/plugins/dali-script-v8/src/actors/mesh-actor-api.cpp b/plugins/dali-script-v8/src/actors/mesh-actor-api.cpp
new file mode 100644
index 0000000..f744758
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/mesh-actor-api.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "mesh-actor-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace //unnamed name space
+{
+
+MeshActor GetMeshActor( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return MeshActor::DownCast( handleWrapper->mHandle );
+}
+
+} //unnamed name space
+
+/***************************************
+ * MESH ACTOR FUNCTIONS
+ ****************************************/
+/**
+ * @constructor
+ * @for MeshActor
+ * @method MeshActor
+ * @return {Object} MeshActor
+ */
+Actor MeshActorApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  return MeshActor::New();
+}
+/**
+ *
+ * @for MeshActor
+ * @method SetAffectedByLighting
+ * @param {Boolean} true = yes affected by lighting
+ */
+void MeshActorApi::SetAffectedByLighting( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  MeshActor actor =  GetMeshActor( isolate, args );
+
+  bool parameterFound( false );
+  bool afftedByLight = V8Utils::GetBooleanParameter(  PARAMETER_0, parameterFound, isolate, args );
+  if( !parameterFound )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter");
+    return;
+  }
+  actor.SetAffectedByLighting( afftedByLight  );
+}
+/**
+ *
+ * @for MeshActor
+ * @method IsAffectedByLighting
+ * @return {Boolean} true = yes affected by lighting
+ */
+void MeshActorApi::IsAffectedByLighting( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  MeshActor actor =  GetMeshActor( isolate, args );
+
+  args.GetReturnValue().Set(  v8::Boolean::New( isolate, actor.IsAffectedByLighting() ) );
+
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/mesh-actor-api.h b/plugins/dali-script-v8/src/actors/mesh-actor-api.h
new file mode 100644
index 0000000..cf0fc02
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/mesh-actor-api.h
@@ -0,0 +1,52 @@
+#ifndef __DALI_V8PLUGIN_MESH_ACTOR_API_H__
+#define __DALI_V8PLUGIN_MESH_ACTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace MeshActorApi
+{
+  /**
+   * constructor
+   */
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Mesh actor API
+   */
+  void SetAffectedByLighting( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsAffectedByLighting( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+
+}; // namespace MeshActorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_MESH_ACTOR_API_H__
diff --git a/plugins/dali-script-v8/src/actors/renderable-actor-api.cpp b/plugins/dali-script-v8/src/actors/renderable-actor-api.cpp
new file mode 100644
index 0000000..89b3569
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/renderable-actor-api.cpp
@@ -0,0 +1,546 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "renderable-actor-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace //unnamed name space
+{
+RenderableActor GetRenderableActor( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return RenderableActor::DownCast( handleWrapper->mHandle );
+}
+}
+/***************************************
+ * RENDERABLE ACTOR FUNCTIONS
+ *
+ ****************************************/
+/**
+ * Allows modification of an actors position in the depth sort algorithm.
+ *
+ * The offset can be altered for each coplanar actor hence allowing an order of painting.
+ * @param { Number }  depthOffset the offset to be given to the actor. Positive values pushing it further back.
+ * @for RenderableActor
+ * @method setSortModifier
+ */
+void RenderableActorApi::SetSortModifier( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  bool found( false );
+  float value = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 0.f );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+  actor.SetSortModifier( value );
+}
+
+/**
+ * Retrieves the offset used to modify an actors position in the depth sort algorithm.
+ * @for RenderableActor
+ * @method getSortModifier .
+ * @return { Number} the offset that has been given to the actor. Positive values pushing it further back
+ */
+void RenderableActorApi::GetSortModifier( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Number::New( isolate, actor.GetSortModifier() ) );
+
+}
+
+/**
+ * Set the face-culling mode for this actor.
+ * @for RenderableActor
+ * @method setCullFace
+ * @param {Number} cullMode
+ * @example
+ *      // cull mode should be one of the following constants
+ *      dali.CULL_FACE_DISABLE        // Face culling disabled
+ *      dali.CULL_FRONT_FACE          // Cull front facing polygons
+ *      dali.CULL_BACK_FACE           // Cull back facing polygons
+ *      dali.CULL_FRONT_AND_BACK_FACE // Cull front and back facing polygons
+ *      actor.SetCullFace( dali.CULL_FRONT_FACE );
+ */
+void RenderableActorApi::SetCullFace( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  bool found( false );
+  int cullMode = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+
+  actor.SetCullFace(  static_cast( cullMode ) );
+
+}
+
+/**
+ * Retrieve the face-culling mode for this actor.
+ * @for RenderableActor
+ * @method getCullFace
+ * @return {Number} cullMode
+ * @example
+ *      // cull mode is one of the following
+ *      dali.CULL_FACE_DISABLE        // Face culling disabled
+ *      dali.CULL_FRONT_FACE          // Cull front facing polygons
+ *      dali.CULL_BACK_FACE           // Cull back facing polygons
+ *      dali.CULL_FRONT_AND_BACK_FACE // Cull front and back facing polygon
+ */
+void RenderableActorApi::GetCullFace( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, actor.GetCullFace() ) );
+
+}
+
+/**
+ * Sets the blending mode.
+ *
+ * If blending is disabled (BLENDING_OFF) fade in and fade out animations do not work.
+ *
+ * @example
+ *      // blend mode is one of the following
+ *      dali.BLENDING_OFF       // Blending is disabled.
+ *      dali.BLENDING_AUTO      // Blending is enabled if there is alpha channel.
+ *      dali.BLENDING_ON        // Blending is enabled.
+ *      actor.SetBlendMode( dali.BLENDING_AUTO );
+ *
+ * @for RenderableActor
+ * @method setBlendMode
+ * @param { Number } blendMode
+ */
+void RenderableActorApi::SetBlendMode( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  bool found( false );
+  int mode = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid BlendMode parameter" );
+    return;
+  }
+  actor.SetBlendMode( static_cast( mode ) );
+
+}
+
+/**
+ * @for RenderableActor
+ * @method getBlendMode
+ * @return { Number } blendMode
+ * @example returns one of the following:
+ *
+ *        dali.BLENDING_OFF       // Blending is disabled.
+ *        dali.BLENDING_AUTO      // Blending is enabled if there is alpha channel.
+ *        dali.BLENDING_ON        // Blending is enabled.
+ *
+ */
+void RenderableActorApi::GetBlendMode( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, actor.GetBlendMode() ) );
+
+}
+
+// 2 function definitions, as Dali uses 2 functions.
+// JavaScript can't overload but we can document it twice with different params
+/**
+ * @for RenderableActor
+ * @method setBlendFunc
+ * @param {Number} SourceBlending RGBA
+ * @param {Number} DestinationBlending RGBA
+ * @example
+ *      blending constants
+      dali.BLEND_FACTOR_ZERO
+      dali.BLEND_FACTOR_ONE
+      dali.BLEND_FACTOR_SRC_COLOR
+      dali.BLEND_FACTOR_ONE_MINUS_SRC_COLOR
+      dali.BLEND_FACTOR_SRC_ALPHA
+      dali.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+      dali.BLEND_FACTOR_DST_ALPHA
+      dali.BLEND_FACTOR_ONE_MINUS_DST_ALPHA
+      dali.BLEND_FACTOR_DST_COLOR
+      dali.BLEND_FACTOR_ONE_MINUS_DST_COLOR
+      dali.BLEND_FACTOR_SRC_ALPHA_SATURATE
+      dali.BLEND_FACTOR_CONSTANT_COLOR
+      dali.BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR
+      dali.BLEND_FACTOR_CONSTANT_ALPHA
+      dali.BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
+
+      actor.setBlendFunc( dali.BLEND_FACTOR_ONE_MINUS_SRC_COLOR, dali.BLEND_FACTOR_ONE_MINUS_DST_COLOR);
+ */
+
+/**
+ * @for RenderableActor
+ * @method setBlendFunc
+ * @param {Number} SourceBlending RGB
+ * @param {Number} DestinationBlending RGB
+ * @param {Number} SourceBlending Alpha
+ * @param {Number} DestinatinoBlending Alpha
+ * @example
+ *      //blending constants
+      dali.BLEND_FACTOR_ZERO
+      dali.BLEND_FACTOR_ONE
+      dali.BLEND_FACTOR_SRC_COLOR
+      dali.BLEND_FACTOR_ONE_MINUS_SRC_COLOR
+      dali.BLEND_FACTOR_SRC_ALPHA
+      dali.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
+      dali.BLEND_FACTOR_DST_ALPHA
+      dali.BLEND_FACTOR_ONE_MINUS_DST_ALPHA
+      dali.BLEND_FACTOR_DST_COLOR
+      dali.BLEND_FACTOR_ONE_MINUS_DST_COLOR
+      dali.BLEND_FACTOR_SRC_ALPHA_SATURATE
+      dali.BLEND_FACTOR_CONSTANT_COLOR
+      dali.BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR
+      dali.BLEND_FACTOR_CONSTANT_ALPHA
+      dali.BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
+
+      actor.setBlendFunc(  dali.BLEND_FACTOR_CONSTANT_COLOR, BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
+                                dali.BLEND_FACTOR_CONSTANT_ALPHA, BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA);
+
+      );
+ */
+void RenderableActorApi::SetBlendFunc( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor =  GetRenderableActor( isolate, args );
+
+  int params[4];
+  if( args.Length() == 2 )
+  {
+    bool foundAllParams(false);
+    V8Utils::ReadIntegerArguments( foundAllParams, ¶ms[0], 2, args,0 );
+    if( foundAllParams )
+    {
+      actor.SetBlendFunc(  static_cast< Dali::BlendingFactor::Type>(params[0]),
+                           static_cast< Dali::BlendingFactor::Type>(params[1]) );
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid BlendMode parameter");
+      return;
+    }
+  }
+  else if ( args.Length() == 4)
+  {
+    bool foundAllParams(false);
+    V8Utils::ReadIntegerArguments( foundAllParams, ¶ms[0], 4, args,0 );
+    if( foundAllParams )
+    {
+      actor.SetBlendFunc(  static_cast< Dali::BlendingFactor::Type>(params[0]),
+                           static_cast< Dali::BlendingFactor::Type>(params[1]),
+                           static_cast< Dali::BlendingFactor::Type>(params[2]),
+                           static_cast< Dali::BlendingFactor::Type>(params[3]));
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid BlendMode parameter");
+      return;
+    }
+  }
+
+}
+
+/**
+ * @for RenderableActor
+ * @method GetBlendFunc
+ * @return {Object} BlendProperties
+ * @example Blend properties object has 4 fields
+ *
+ *      blendProperties.sourceRgb // source rgb enum
+ *      blendProperties.destinationRgb  // destination rgb enum
+ *      blendProperties.sourceAlpha source // alpha enum
+ *      blendProperties.destinationAlpha // destination alpha enum
+ */
+void RenderableActorApi::GetBlendFunc( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  // @todo pass by reference doesn't work in Javascript so need to decide what to return
+  // for now just return a vector 4...
+
+  BlendingFactor::Type srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha;
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+
+  v8::Local blendInfo = v8::Object::New( isolate );
+
+  blendInfo->Set( v8::String::NewFromUtf8( isolate, "sourceRgb" ),        v8::Integer::New( isolate, srcFactorRgb) );
+  blendInfo->Set( v8::String::NewFromUtf8( isolate, "destinationRgb" ),   v8::Integer::New( isolate, destFactorRgb ) );
+  blendInfo->Set( v8::String::NewFromUtf8( isolate, "sourceAlpha" ),      v8::Integer::New( isolate, srcFactorAlpha  ) );
+  blendInfo->Set( v8::String::NewFromUtf8( isolate, "destinationAlpha" ), v8::Integer::New( isolate, destFactorAlpha ) );
+
+  args.GetReturnValue().Set( blendInfo );
+
+}
+// 2 function definitions, as Dali uses 2 functions.
+// JavaScript can't overload but we can document it twice with different params
+/**
+ * @for RenderableActor
+ * @method setBlendEquation
+ * @param {Number } BlendEquation for RGBA
+ * @example
+ *
+ *      //blending equation constants
+      dali.BLEND_EQUATION_ADD
+      dali.BLEND_EQUATION_SUBTRACT
+      dali.BLEND_EQUATION_REVERSE_SUBTRACT
+      actor.setBlendEquation( dali.BLEND_EQUATION_ADD );
+
+ */
+
+/**
+ * @for RenderableActor
+ * @method setBlendEquation
+ * @param {Number } BlendEquation for RGB
+ * @param {Number } BlendEquation for Alpha
+ * @example
+ *
+ *      //blending equation constants
+      dali.BLEND_EQUATION_ADD
+      dali.BLEND_EQUATION_SUBTRACT
+      dali.BLEND_EQUATION_REVERSE_SUBTRACT
+      actor.setBlendEquationSeparate( dali.BLEND_EQUATION_ADD, dali.BLEND_EQUATION_SUBTRACT  );
+
+ */
+void RenderableActorApi::SetBlendEquation( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  int params[2];
+  if( args.Length() == 1 )
+  {
+    bool foundAllParams( false );
+    V8Utils::ReadIntegerArguments( foundAllParams, ¶ms[0], 1, args, 0 );
+    if( foundAllParams )
+    {
+      actor.SetBlendEquation( static_cast( params[0] ) );
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid BlendEquation parameter" );
+      return;
+    }
+  }
+  else if( args.Length() == 2 )
+  {
+    bool foundAllParams( false );
+    V8Utils::ReadIntegerArguments( foundAllParams, ¶ms[0], 2, args, 0 );
+    if( foundAllParams )
+    {
+      actor.SetBlendEquation( static_cast( params[0] ), static_cast( params[1] ) );
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid BlendEquation parameter" );
+      return;
+    }
+  }
+}
+
+/**
+ * @for RenderableActor
+ * @method getBlendEquation
+ * @return {Object} equationProperties
+ * @example equation properties object has 2 fields
+ *
+ *      equationProperties.equationRgb    // rbg blend equation
+ *      equationProperties.equationAlpha  // alpha blend equation
+ */
+void RenderableActorApi::GetBlendEquation( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  BlendingEquation::Type equationRgb, equationAlpha;
+  actor.GetBlendEquation( equationRgb, equationAlpha );
+
+  v8::Local object = v8::Object::New( isolate );
+
+  object->Set( v8::String::NewFromUtf8( isolate, "equationRgb" ),   v8::Integer::New( isolate, equationRgb) );
+  object->Set( v8::String::NewFromUtf8( isolate, "equationAlpha" ), v8::Integer::New( isolate, equationAlpha ) );
+
+  args.GetReturnValue().Set( object );
+}
+
+/**
+ * @for RenderableActor
+ * @method setBlendColor
+ * @param {Vector4} Color
+ * @example
+ *
+ *        actor.SetBlendColor( dali.COLOR_RED );
+ */
+void RenderableActorApi::SetBlendColor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  Dali::Vector4 color;
+
+  bool foundAllArguments( false );
+
+  V8Utils::ReadFloatArguments( foundAllArguments, color.AsFloat(), 4, args, 1.f ); // read the parameters
+  if( !foundAllArguments )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid color parameter, should red,green,blue,alpha" );
+    return;
+  }
+  actor.SetBlendColor( color );
+
+}
+
+/**
+ * @for RenderableActor
+ * @method getBlendColor
+ * @return {Object} Dali vector 4 object
+ */
+void RenderableActorApi::GetBlendColor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  Dali::Vector4 color = actor.GetBlendColor();
+
+  Dali::Property::Value value( color );
+
+  v8::Local object = PropertyValueWrapper::WrapDaliProperty( isolate, value );
+
+  args.GetReturnValue().Set( object );
+
+}
+
+
+/**
+ * @for RenderableActor
+ * @method getShaderEffect
+ * @return {Object} ShaderEffect object
+ *
+ * Retrieve the shader effect for the Actor.
+ *
+ * @example
+ *    var shaderEffect = actor.getShaderEffect();
+ *
+ */
+void RenderableActorApi::GetShaderEffect( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  v8::Local < v8::Object > object = ShaderEffectWrapper::WrapShaderEffect( isolate, actor.GetShaderEffect() );
+  args.GetReturnValue().Set( object );
+
+}
+
+/**
+ * @for RenderableActor
+ * @method setShaderEffect
+ * @param {Object} shaderEffect The shader effect.
+ *
+ * Sets the shader effect for the Actor.
+ *
+ * Shader effects provide special effects like rippling and bending.
+ * Setting a shader effect removes any shader effect previously set by SetShaderEffect.
+ * @example
+ *      // first create the shaderOptions, then the shaderEffect
+ *      var shader = new dali.ShaderEffect( shaderOptions );
+ *      actor.setShaderEffect( shader );
+ *
+ */
+void RenderableActorApi::SetShaderEffect( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+
+  bool found( false );
+  ShaderEffect effect = ShaderEffectApi::GetShaderEffectFromParams( 0, found, isolate, args );
+  if( found )
+  {
+    actor.SetShaderEffect( effect );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "shader effect parameter missing" );
+  }
+}
+
+/**
+ *
+ * Removes the current shader effect
+ *
+ * @example
+ *    actor.removeShaderEffect();
+ *
+ * @for RenderableActor
+ * @method removeShaderEffect
+ */
+void RenderableActorApi::RemoveShaderEffect( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderableActor actor = GetRenderableActor( isolate, args );
+  actor.RemoveShaderEffect();
+}
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/renderable-actor-api.h b/plugins/dali-script-v8/src/actors/renderable-actor-api.h
new file mode 100644
index 0000000..463b295
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/renderable-actor-api.h
@@ -0,0 +1,62 @@
+#ifndef __DALI_V8PLUGIN_RENDERABLE_ACTOR_API_H__
+#define __DALI_V8PLUGIN_RENDERABLE_ACTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace RenderableActorApi
+{
+   /**
+   * RenderableActor API see renderable-actor.h for a description
+   * Unfortunately none of the functions are covered by the property system
+   */
+  void SetSortModifier( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetSortModifier( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetCullFace( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetCullFace( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetBlendMode( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBlendMode( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetBlendFunc( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBlendFunc( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetBlendEquation( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBlendEquation( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetBlendColor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBlendColor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void RemoveShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+}; // namespace RenderableActorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_RENDERABLE_ACTOR_API_H__
diff --git a/plugins/dali-script-v8/src/actors/text-actor-api.cpp b/plugins/dali-script-v8/src/actors/text-actor-api.cpp
new file mode 100644
index 0000000..483b345
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/text-actor-api.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "text-actor-api.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace //unnamed name space
+{
+
+struct TextActorParametersInternal
+{
+  TextActorParametersInternal()
+  : fontDetection( true )
+  {
+  }
+  bool fontDetection;
+  Font font;
+};
+
+
+TextActor GetTextActor( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() );
+  return TextActor::DownCast( handleWrapper->mHandle );
+}
+
+
+void GetTextOptions( v8::Isolate* isolate,
+                          v8::Local options,
+                          TextActorParametersInternal& textParams )
+{
+  //      fontDetection: true / false  ( default  true)
+  //      font: dali font object
+  v8::HandleScope handleScope( isolate );
+
+  if( options->IsObject() )
+  {
+    v8::Local obj = options->ToObject();
+
+    v8::Local fontDetect = obj->Get( v8::String::NewFromUtf8( isolate, "fontDetection" ) );
+    if( fontDetect->IsBoolean() )
+    {
+
+      textParams.fontDetection = fontDetect->ToBoolean()->Value();
+    }
+
+    v8::Local fontValue = obj->Get( v8::String::NewFromUtf8( isolate, "font" ) );
+    if( fontValue->IsObject() )
+    {
+      textParams.font = FontApi::GetFont( isolate, fontValue );
+    }
+
+  }
+}
+
+}
+
+/**
+ * @constructor
+ * @for TextActor
+ * @method TextActor
+ * @param {String} text
+ * @param {Object} [textOptions] data
+ * Options text options struct
+ * @param {Boolean} [textOptions.fontDetection]
+ * if true the fontDetection is used to make sure the text is displayed.
+ * E.g. if the current font used by the text-actor does not support certain characters
+ * it will find a new font that does. Default = true.
+ * @param {Object}  [textOptions.font]
+ * Dali font object
+ * @return {Object} TextActor
+ */
+Actor TextActorApi::New( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  //
+  // TextActor( text, options (optional) )
+  //
+  // options =
+  // {
+  //    font:   font
+  //    fontDetection: true / false   ( default  true)
+  // }
+
+  // get the text (if passed in)
+
+  bool found( false );
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+
+  TextActorParametersInternal params;
+  TextActor actor;
+
+  GetTextOptions( isolate, args[1], params );
+
+  TextStyle style;
+
+  if( params.font )
+  {
+    style.SetFontName( params.font.GetName() );
+    style.SetFontStyle( params.font.GetStyle() );
+    style.SetFontPointSize( PointSize(params.font.GetPointSize()));
+
+  }
+  TextActorParameters textActorParameters( style, params.fontDetection? TextActorParameters::FONT_DETECTION_OFF:TextActorParameters::FONT_DETECTION_ON );
+
+  actor = TextActor::New( text, textActorParameters );
+
+  return actor;
+
+}
+
+/**
+ * Set text to the natural size of the text string.
+ *
+ * After this method the text actor always uses the natural size of the text
+ * when SetText is called unless SetSize is called to override the size.
+ *
+ * @for TextActor
+ * @method setToNaturalSize
+ */
+void TextActorApi::SetToNaturalSize( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  TextActor textActor = GetTextActor( isolate, args );
+  textActor.SetToNaturalSize();
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/actors/text-actor-api.h b/plugins/dali-script-v8/src/actors/text-actor-api.h
new file mode 100644
index 0000000..f074703
--- /dev/null
+++ b/plugins/dali-script-v8/src/actors/text-actor-api.h
@@ -0,0 +1,43 @@
+#ifndef __DALI_V8PLUGIN_TEXT_ACTOR_API_H__
+#define __DALI_V8PLUGIN_TEXT_ACTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace TextActorApi
+{
+  Actor New( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetToNaturalSize( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace TextActorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_TEXT_ACTOR_API_H__
diff --git a/plugins/dali-script-v8/src/animation/animation-api.cpp b/plugins/dali-script-v8/src/animation/animation-api.cpp
new file mode 100644
index 0000000..3fba14a
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/animation-api.cpp
@@ -0,0 +1,1174 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "animation-api.h"
+#include "path-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+// @todo think about alternative ways of passing around
+struct AlphaFuncStruct
+{
+  const char* const name;
+  AlphaFunction alphaFunc;
+};
+/**
+ * Contains a list of alpha functions that can be used.
+ * We use a stl map as lookup to map a string name to the function
+ */
+const AlphaFuncStruct AlphaFunctionTable[]=
+{
+ {"default"               , AlphaFunctions::Default              },
+ {"linear"                , AlphaFunctions::Linear               },
+ {"square"                , AlphaFunctions::Square               },
+ {"reverse"               , AlphaFunctions::Reverse              },
+ {"easeIn"                , AlphaFunctions::EaseIn               },
+ {"easeOut"               , AlphaFunctions::EaseOut              },
+ {"easeInOut"             , AlphaFunctions::EaseInOut            },
+ {"easeInSine"            , AlphaFunctions::EaseInSine           },
+ {"easeOutSine"           , AlphaFunctions::EaseOutSine          },
+ {"easeInOutSine"         , AlphaFunctions::EaseInOutSine        },
+ {"easeInSine33"          , AlphaFunctions::EaseInSine33         },
+ {"easeOutSine33"         , AlphaFunctions::EaseOutSine33        },
+ {"easeInOutSine33"       , AlphaFunctions::EaseInOutSine33      },
+ {"easeInOutSine50"       , AlphaFunctions::EaseInOutSine50      },
+ {"easeInOutSine60"       , AlphaFunctions::EaseInOutSine60      },
+ {"easeInOutSine70"       , AlphaFunctions::EaseInOutSine70      },
+ {"easeInOutSine80"       , AlphaFunctions::EaseInOutSine80      },
+ {"easeInOutSine90"       , AlphaFunctions::EaseInOutSine90      },
+ {"doubleEaseInOutSine60" , AlphaFunctions::DoubleEaseInOutSine60},
+ {"easeOutQuint50"        , AlphaFunctions::EaseOutQuint50       },
+ {"easeOutQuint80"        , AlphaFunctions::EaseOutQuint80       },
+ {"bounce"                , AlphaFunctions::Bounce               },
+ {"bounceBack"            , AlphaFunctions::BounceBack           },
+ {"easeInBack"            , AlphaFunctions::EaseInBack           },
+ {"easeOutBack"           , AlphaFunctions::EaseOutBack          },
+ {"easeInOutBack"         , AlphaFunctions::EaseInOutBack        },
+ {"sin"                   , AlphaFunctions::Sin                  },
+ {"sin2x"                 , AlphaFunctions::Sin2x                }
+};
+const unsigned int AlphaFunctionTableCount = sizeof(AlphaFunctionTable)/sizeof(AlphaFunctionTable[0]);
+const char* const DEFAULT_ALPHA_NAME = "default";
+static AlphaFunction DEFAULT_ALPHA_FUNCTION = AlphaFunctions::Default;
+
+
+
+AlphaFunction GetAlphaFunction( const std::string& alphaFuncName )
+{
+  // This will normally get called just a few times during the application, so no point in doing anything clever
+  for( unsigned int i = 0; i < AlphaFunctionTableCount; i++)
+  {
+    const AlphaFuncStruct& alphaStruct( AlphaFunctionTable[i] );
+
+    if( std::strcmp( alphaStruct.name , alphaFuncName.c_str() ) == 0 )
+    {
+      return alphaStruct.alphaFunc;
+    }
+  }
+
+  DALI_LOG_ERROR("Failed to find alpha func |%s| \n", alphaFuncName.c_str() );
+  return AlphaFunctions::Default;
+}
+
+const char* const GetAlphaFunctionName(  AlphaFunction alphaFunc )
+{
+  // This may get called 3 times during the application, so no point
+  // in doing anything clever
+
+  for( unsigned int i = 0; i < AlphaFunctionTableCount; i++)
+  {
+    const AlphaFuncStruct& alphaStruct( AlphaFunctionTable[i] );
+
+
+    if( alphaStruct.alphaFunc  == alphaFunc )
+    {
+      return alphaStruct.name;
+    }
+  }
+  return "default";
+}
+
+
+struct AnimationParameters
+{
+  AnimationParameters( const Animation& anim)
+  : propertyIndex( Property::INVALID_INDEX  ),
+    alphaFunction( DEFAULT_ALPHA_FUNCTION),
+    delay( 0.f ),
+    duration(anim.GetDuration()),
+    optionsFound( false )
+  {
+  }
+
+  Handle target;
+  Property::Index propertyIndex;
+  Property::Value value;
+  KeyFrames keyFrames;
+  AlphaFunction alphaFunction;
+  float delay;
+  float duration;
+  bool optionsFound;
+};
+
+void GetAnimationOptions( v8::Isolate* isolate,
+                          v8::Local options,
+                          AnimationParameters& animParams )
+{
+  // animation options is an optional parameter passed in which holds
+  // optional settings
+  // var animOptions = {
+  //  alpha: "Bounce",
+  //  delay: 5,
+  //  duration: 20
+  // };
+  v8::HandleScope handleScope( isolate );
+
+  if( options->IsObject() )
+  {
+    v8::Local obj = options->ToObject();
+    v8::Local alphaValue = obj->Get( v8::String::NewFromUtf8( isolate, "alpha" ) );
+    if( alphaValue->IsString() )
+    {
+      animParams.optionsFound = true;
+      std::string alphaName = V8Utils::v8StringToStdString( alphaValue );
+      animParams.alphaFunction = GetAlphaFunction( alphaName );
+    }
+
+    v8::Local delayValue = obj->Get( v8::String::NewFromUtf8( isolate, "delay" ) );
+    if( delayValue->IsNumber() )
+    {
+      animParams.optionsFound = true;
+      v8::Local num = delayValue->ToNumber();
+      animParams.delay = num->Value();
+    }
+
+    v8::Local durationValue = obj->Get( v8::String::NewFromUtf8( isolate, "duration" ) );
+    if( durationValue->IsNumber() )
+    {
+      animParams.optionsFound = true;
+      v8::Local num = durationValue->ToNumber();
+      animParams.duration = num->Value();
+    }
+
+  }
+}
+KeyFrames GetKeyFrames( v8::Isolate* isolate, v8::Local keyFrameArray )
+{
+  // keyframe object is an array of
+  // {
+  //   float: progress
+  //   value: property value ( position/ rotation etc)
+  //   alpha: function
+  //
+  v8::HandleScope handleScope( isolate );
+
+  if( !keyFrameArray->IsObject() || !keyFrameArray->IsArray() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing keyframe array" );
+    return KeyFrames();
+  }
+
+  KeyFrames keyframes = KeyFrames::New();
+
+  v8::Local array = v8::Local::Cast( keyFrameArray );
+  for( uint32_t i=0; i < array->Length() ; ++i)
+  {
+    v8::Handle arrayItem =  array->Get( i );
+
+    if(!arrayItem->IsObject() )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "missing keyframe object" );
+      return KeyFrames();
+    }
+    v8::Handle keyFrameObject = arrayItem->ToObject();
+
+    // get keyframe.progress
+    v8::Handle progress = keyFrameObject->Get(v8::String::NewFromUtf8( isolate, "progress"));
+    if( !progress->IsNumber() )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "keyframe missing progress property" );
+      return keyframes;
+    }
+
+    // get keyframe.value
+    bool found(false);
+    v8::Handle propertyValue = keyFrameObject->Get(v8::String::NewFromUtf8( isolate, "value"));
+    Property::Value value =  V8Utils::GetPropertyValueFromObject( found, isolate, propertyValue );
+    if( !found )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "keyframe missing value property" );
+      return keyframes;
+    }
+
+    // get keyframe.alpha
+    v8::Handle alphaValue = keyFrameObject->Get(v8::String::NewFromUtf8( isolate, "alpha"));
+    if( alphaValue->IsString() )
+    {
+      std::string alphaName = V8Utils::v8StringToStdString( alphaValue );
+      AlphaFunction alphaFunction = GetAlphaFunction( alphaName );
+      keyframes.Add( progress->NumberValue(), value, alphaFunction );
+    }
+    else
+    {
+      keyframes.Add( progress->NumberValue(), value );
+    }
+
+  }
+  return keyframes;
+
+}
+bool GetAnimationParameters(  v8::Isolate* isolate,
+                              const v8::FunctionCallbackInfo< v8::Value >& args,
+                              AnimationParameters& animParams,
+                              AnimationApi::AnimationParameterType type)
+{
+  // used for things like anim.AnimateBy(  myImageActor, property-name,  property-value (or Javascript number array));
+  // 1 extract property handle from param1.
+  // 2 extract property name from param2  ( can be in the format "u-color" or "uColor"
+  // 3 extract PropertyValue from param3
+  // 4 extract animation options ( delay, duration, alpha func)
+
+  // 1 extract HANDLE
+  bool foundHandle;
+  animParams.target = V8Utils::GetHandleParameter( PARAMETER_0, foundHandle, isolate, args );
+  if( !foundHandle )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 (Handle)" );
+    return false;
+  }
+
+  // 2 extract property name
+  bool foundPropName;
+  std::string propertyName = V8Utils::GetStringParameter( PARAMETER_1, foundPropName, isolate, args );
+  if( !foundPropName )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 1 ( PropertyName )" );
+    return false;
+  }
+  // try both properties with dashes and without
+  Property::Index index = animParams.target.GetPropertyIndex( propertyName );
+
+  if( index == Property::INVALID_INDEX )
+  {
+    // convert the property name from "uColor" to "u-color"
+    std::string convetedName = V8Utils::JavaScriptNameToPropertyName( propertyName );
+    index = animParams.target.GetPropertyIndex( convetedName );
+  }
+
+  animParams.propertyIndex = index;
+
+  if( type == AnimationApi::PROPERTY_VALUE )
+  {
+    // 3 extract property value
+    bool foundPropValue( false );
+    animParams.value = V8Utils::GetPropertyValueParameter( PARAMETER_2, foundPropValue, isolate, args );
+    if( !foundPropValue )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 2 ( value )" );
+      return false;
+    }
+  }
+  else  // type == KEYFRAMES
+  {
+    animParams.keyFrames = GetKeyFrames(isolate, args[2]);
+  }
+  // 4 extract animation options
+  GetAnimationOptions( isolate, args[3], animParams );
+
+  return true;
+}
+
+Animation GetAnimation( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField( 0 ) );
+  void* ptr = field->Value();
+
+  AnimationWrapper* wrapper = static_cast( ptr );
+  return wrapper->GetAnimation();
+}
+
+
+} // un-named namespace
+
+/**
+ * Constructor
+ *
+ * @constructor
+ * @for Animation
+ * @method Animation
+ * @param {float} duration
+ *
+ */
+Animation AnimationApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  float value = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 1.f /* default */);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return Animation();
+  }
+  // get the duration
+  return Animation::New( value );
+}
+
+/**
+ * Set the animation duration.
+ * @method setDuration
+ * @for Animation
+ * @param {float} duration in seconds
+ *
+ */
+void AnimationApi::SetDuration( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+  float value = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 1.f /* default */);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+  anim.SetDuration( value );
+}
+/**
+ * Get the animation duration.
+ * @method getDuration
+ * @for Animation
+ * @return {float} duration in seconds
+ *
+ */
+void AnimationApi::GetDuration( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  args.GetReturnValue().Set( v8::Number::New( isolate, anim.GetDuration() ) );
+
+}
+/**
+ * Set whether the animation will loop.
+ * @method setLooping
+ * @for Animation
+ * @param {bool} looping enabled
+ *
+ */
+void AnimationApi::SetLooping( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+  bool value = V8Utils::GetBooleanParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+  }
+  else
+  {
+    anim.SetLooping( value );
+  }
+
+}
+/**
+ * Query whether the animation will loop.
+ * @method isLooping
+ * @for Animation
+ * @return {bool} looping enabled
+ *
+ */
+void AnimationApi::IsLooping( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, anim.IsLooping() ) );
+}
+
+/**
+ * Set the end action of the animation.
+ *
+ * This action is performed when the animation ends.
+ * Default end action is bake
+ * @method setEndAction
+ * @for Animation
+ * @param {integer} bake mode
+ * @example
+ *       anim.setEndAction( dali.ANIMATION_BAKE ); // When the animation ends, the animated property values are saved.
+ *       anim.setEndAction( dali.ANIMATION_DISCARD ); //  When the animation ends, the animated property values are forgotten.
+ *       anim.setEndAction( dali.ANIMATION_BAKE_FINAL ); // If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Bake.
+ */
+void AnimationApi::SetEndAction( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+  int value = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+  }
+  else
+  {
+    anim.SetEndAction( static_cast( value ) );
+  }
+}
+
+/**
+ * Returns the end action of the animation.
+
+ * @method getEndAction
+ * @for Animation
+ * @return {integer} bake mode
+ *
+ * There are 3 different bake modes
+ * @example
+ *     dali.ANIMATION_BAKE  // When the animation ends, the animated property values are saved.
+ *     dali.ANIMATION_DISCARD // When the animation ends, the animated property values are forgotten.
+ *     dali.ANIMATION_BAKE_FINAL  // If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Bake.
+ */
+void AnimationApi::GetEndAction( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, anim.GetEndAction() ) );
+}
+
+/**
+ * Set the disconnect action of the animation.
+ * If any of the animated property owners are disconnected from the stage, this action is performed.
+ * Default disconnection action is BakeFinal.
+ * @method setDisconnectAction
+ * @for Animation
+ * @param {integer} end mode
+ *
+ * There are 3 different end modes
+ * @example
+ *     dali.ANIMATION_BAKE  // When the animation is destroyed, the animated property values are saved.
+ *     dali.ANIMATION_DISCARD // When the animation is destroyed, the animated property values are forgotten.
+ *     dali.ANIMATION_BAKE_FINAL  // When the animation is destroyed, the animated property values are saved as if the animation had run to completion, otherwise behaves like Bake.
+ */
+void AnimationApi::SetDisconnectAction( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+  int value = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+  }
+  else
+  {
+    anim.SetDisconnectAction( static_cast( value ) );
+  }
+}
+
+/**
+ * Returns the disconnect action of the animation.
+ * @method getDisconnectAction
+ * @for Animation
+ * @return {integer} end mode
+ */
+void AnimationApi::GetDisconnectAction( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, anim.GetDisconnectAction() ) );
+}
+/**
+ * Set the default alpha function for an animation.
+ * @method setDefaultAlphaFunction
+ * @for Animation
+ * @param {string} alpha function
+ */
+void AnimationApi::SetDefaultAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+  std::string alphaFunc = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+  }
+  else
+  {
+    AlphaFunction func = GetAlphaFunction( alphaFunc );
+    anim.SetDefaultAlphaFunction( func );
+  }
+
+}
+/**
+ * Get the default alpha function for an animation.
+ * @method getDefaultAlphaFunction
+ * @for Animation
+ * @return {string} alpha function
+ */
+void AnimationApi::GetDefaultAlphaFunction( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  std::string alphaName = GetAlphaFunctionName(  anim.GetDefaultAlphaFunction() );
+
+
+  args.GetReturnValue().Set( v8::String::NewFromUtf8( isolate, alphaName.c_str() ) );
+}
+
+/**
+ * Get the current progress of the animation.
+ * @method getCurrentProgress
+ * @for Animation
+ * @return {float} The current progress as a normalized value between [0..1].
+ *
+ */
+void AnimationApi::GetCurrentProgress( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  args.GetReturnValue().Set( v8::Number::New( isolate, anim.GetCurrentProgress() ) );
+}
+
+/**
+ * Specifies an speed factor for the animation.
+ *
+ * The speed factor is a multiplier of the normal velocity of the animation. Values between [0,1] will
+ * slow down the animation and values above one will speed up the animation. It is also possible to specify a negative multiplier
+ * to play the animation in reverse.
+ *
+ * @method setSpeedFactor
+ * @for Animation
+ * @param {float}  value which will multiply the velocity.
+ * @example
+ *     anim.setSpeedFactor(2);
+ *     anim.play();             // plays the animation twice as fast
+ *
+ *
+ *     anim.setSpeedFactor(0.5);
+ *     anim.play();             // plays the animation half speed
+ *
+ */
+void AnimationApi::SetSpeedFactor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+  float speedFactor = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 0.f );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "float parameter missing" );
+  }
+  else
+  {
+    anim.SetSpeedFactor( speedFactor );
+  }
+
+}
+
+/**
+ * Retrieve the speed factor of the animation
+ *
+ *
+ * @method getSpeedFactor
+ * @for Animation
+ * @return {float} speed factor
+ */
+void AnimationApi::GetSpeedFactor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  args.GetReturnValue().Set( v8::Number::New( isolate, anim.GetSpeedFactor() ) );
+}
+
+/**
+ * Set the playing range.
+ * Animation will play between the values specified.
+ * Both values ( range.x and range.y ) should be between 0-1,
+ * otherwise they will be ignored.
+ * If the range provided is not in proper order ( minimum,maximum), it will be reordered.
+ * @method setPlayRange
+ * @for Animation
+ * @param {Object} Range
+ * @param {Float} Range.start
+ * @param {Float} Range.end
+ * @example
+ *     var range = {  start:0.1, end:0.6 };
+ *     anim.setPlayRange( range );
+ */
+void AnimationApi::SetPlayRange( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  Vector2 range(0,0);
+
+  if( args.Length() != 1 )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing / invalid parameters" );
+    return;
+  }
+  v8::Local rangeValue = args[0];
+  if( !rangeValue->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid parameters" );
+    return;
+  }
+  v8::Local obj = rangeValue->ToObject();
+  v8::Local startValue = obj->Get( v8::String::NewFromUtf8( isolate, "start" ) );
+  v8::Local endValue = obj->Get( v8::String::NewFromUtf8( isolate, "end" ) );
+
+  if( startValue->IsNumber() &&  endValue->IsNumber())
+  {
+        range.x= startValue->ToNumber()->Value();
+        range.y = endValue->ToNumber()->Value();
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing start/end value" );
+    return;
+  }
+
+  anim.SetPlayRange( range );
+
+}
+
+/**
+ * Get the playing range.
+ * @method getPlayRange
+ * @for Animation
+ * @return {Object} Range with { start: ,  end: } properties.
+ */
+void AnimationApi::GetPlayRange( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::EscapableHandleScope handleScope( isolate );
+  Animation anim = GetAnimation( isolate, args );
+
+
+  v8::Local rangeObject = v8::Object::New( isolate );
+
+  Vector2 range = anim.GetPlayRange();
+
+ // set device id
+  rangeObject->Set( v8::String::NewFromUtf8( isolate, "start"), v8::Number::New( isolate,range.x ));
+
+   // set state
+  rangeObject->Set( v8::String::NewFromUtf8( isolate, "end"), v8::Number::New( isolate,range.y ));
+
+  args.GetReturnValue().Set( rangeObject );
+}
+
+
+/**
+ * Sets the progress of the animation.
+ * The animation will play (or continue playing) from this point. The progress
+ * must be in the 0-1 interval or in the play range interval if defined ( See SetPlayRange ),
+ * otherwise, it will be ignored.
+ *
+ * @method setCurrentProgress
+ * @for Animation
+ * @param {float}  progress The new progress as a normalized value between [0,1] or between the
+ * play range if specified.
+ */
+void AnimationApi::SetCurrentProgress( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+
+  float progress = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 0.f );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "float parameter missing" );
+    return;
+  }
+  anim.SetCurrentProgress( progress );
+
+}
+
+/**
+ *
+ *  Play the animation from a given point.
+ * The progress must be in the 0-1 interval or in the play range interval if defined ( See SetPlayRange ),
+ * otherwise, it will be ignored.
+ * @method playFrom
+ * @for Animation
+ * @param {float} progress A value between [0,1], or between the play range if specified, form where the animation should start playing
+ */
+void AnimationApi::PlayFrom( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+
+  bool found( false );
+
+  float progress = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 0.f );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "float parameter missing" );
+    return;
+  }
+  anim.PlayFrom( progress );
+
+}
+
+/**
+ * Play the animation
+ * @method play
+ * @for Animation
+ */
+void AnimationApi::Play( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  anim.Play();
+}
+/**
+ * Pause the animation
+ * @method pause
+ * @for Animation
+ */
+void AnimationApi::Pause( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  anim.Pause();
+}
+/**
+ * Stop the animation
+ * @method stop
+ * @for Animation
+ */
+void AnimationApi::Stop( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  anim.Stop();
+}
+/**
+ * Clear the animation
+ * This disconnects any objects that were being animated, effectively stopping the animation.
+ * @method clear
+ * @for Animation
+ */
+void AnimationApi::Clear( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  anim.Clear();
+}
+
+
+void AnimationApi::Animate( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  AnimationParameters animParams( anim );
+  bool found(false);
+
+  //Get actor
+  Dali::Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing actor parameter");
+    return;
+  }
+
+  //Get path
+  Dali::Path path;
+  BaseWrappedObject* wrapper = V8Utils::GetWrappedDaliObjectParameter( PARAMETER_1, BaseWrappedObject::PATH, isolate, args);
+  PathWrapper* pathWrapper = static_cast< PathWrapper*>( wrapper );
+  if( !pathWrapper )
+  {
+    return;
+  }
+  path = pathWrapper->GetPath();
+
+  //Get forward vector
+  bool bFound(false);
+  Vector3 forward = V8Utils::GetVector3Parameter( PARAMETER_2, bFound, isolate, args );
+  if( !bFound )
+  {
+    return;
+  }
+
+  //Get animation options
+  GetAnimationOptions( isolate, args[3], animParams );
+  if( animParams.optionsFound )
+  {
+    anim.Animate( actor, path, forward, animParams.alphaFunction, TimePeriod( animParams.delay, animParams.duration) );
+  }
+  else
+  {
+    anim.Animate( actor, path, forward );
+  }
+}
+
+/**
+ *
+ * Animate a property value by a relative amount.
+ *
+ * The effect will start & end when the animation begins & ends.
+ * @method animateBy
+ * @for Animation
+ * @param {Object} target object that contains a property to be animated (e.g. myActor )
+ * @param {String} property name (e.g. "position" )
+ * @param {Object} relativeValue The property value will change by this amount.
+ * @param {Object} [options] Animation options.
+ * @param {Float} [options.delay] amount to delay the start of the animation in seconds
+ * @param {Float} [options.duration] duration of the animation
+ * @param {String} [options.alpha] Animation alpha function (e.g. "linear")
+ *
+ * @example
+ *
+ *     // animation x position
+ *     var anim = new dali.Animation( 1 );
+ *     anim.animateBy( imageActor,"positionX", 30 );
+ *     anim.play();
+ *
+ *     // animate x,y,z position with the optional animation options
+ *     var options = {
+ *        delay: 3,     // 3 second delay before starting
+ *        duration: 5,  // 5 second duration
+ *        alpha:"easeInOutSine"   // Speeds up and slows to a gradual stop
+ *     }
+ *
+ *     anim.animateBy( imageActor,"position", [100,200,0], options );
+ *
+ */
+void AnimationApi::AnimateBy( const v8::FunctionCallbackInfo& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  AnimationParameters animParams( anim );
+
+  // grab all the parameters
+  bool ok = GetAnimationParameters( isolate, args, animParams, AnimationApi::PROPERTY_VALUE);
+  if( !ok )
+  {
+    // GetAnimationParameters will log
+    return;
+  }
+
+  if( animParams.optionsFound )
+  {
+    anim.AnimateBy( Property( animParams.target, animParams.propertyIndex ),
+                              animParams.value,
+                              animParams.alphaFunction,
+                              TimePeriod( animParams.delay, animParams.duration) );
+  }
+  else
+  {
+    anim.AnimateBy( Property( animParams.target, animParams.propertyIndex ), animParams.value );
+  }
+
+}
+
+/**
+ *
+ * Animate a property to a destination value.
+ *
+ * The effect will start & end when the animation begins & ends.
+ * @method animateTo
+ * @for Animation
+ * @param {Object} target object that contains a property to be animated (e.g. myActor )
+ * @param {String} property name (e.g. "position" )
+ * @param {Object} destinationValue The property value will changed to this value
+ * @param {Object} [options] Animation options.
+ * @param {Float} [options.delay] amount to delay the start of the animation in seconds
+ * @param {Float} [options.duration] duration of the animation
+ * @param {String} [options.alpha] Animation alpha function (e.g. "linear")
+ *
+ * @example
+ *
+ *     var anim = new dali.Animation( 1 );
+ *     anim.animateTo( imageActor,"positionX", 30 );
+ *     anim.play();
+ *
+ *
+ *     // with the optional animation options object
+ *     var options = {
+ *        delay: 3,     // 3 second delay before starting
+ *        duration: 5,  // 5 second duration
+ *        alpha:"easeInOutSine"   // Speeds up and slows to a gradual stop
+ *     }
+ *
+ *     anim.animateTo( imageActor,"position", [100,200,0], options );
+ *
+ */
+void AnimationApi::AnimateTo( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  AnimationParameters animParams( anim );
+
+  // grab all the parameters
+  bool ok = GetAnimationParameters( isolate, args, animParams, AnimationApi::PROPERTY_VALUE );
+  if( !ok )
+  {
+    // GetAnimationParameters will log
+    return;
+  }
+
+  if( animParams.optionsFound )
+  {
+
+    anim.AnimateTo( Property( animParams.target,animParams.propertyIndex ),
+                                  animParams.value,
+                                  animParams.alphaFunction,
+                                  TimePeriod( animParams.delay, animParams.duration) );
+  }
+  else
+  {
+    anim.AnimateTo( Property( animParams.target, animParams.propertyIndex ), animParams.value );
+  }
+}
+
+/**
+ *
+ * Animate a property between keyframes.
+ *
+ * The effect will start & end when the animation begins & ends.
+ * @method animateBetween
+ * @for Animation
+ * @param {Object} target object that contains a property to be animated (e.g. myActor )
+ * @param {String} property name (e.g. "position" )
+ * @param {Object} keyframes array of keyframe objects
+ * @param {Object} [options] Animation options.
+ * @param {Float} [options.delay] amount to delay the start of the animation in seconds
+ * @param {Float} [options.duration] duration of the animation
+ * @param {String} [options.alpha] Animation alpha function (e.g. "linear")
+ *
+ *
+ * @example
+ *
+ *  create some keyframes to move an actor around a square, and return to the start
+ * 
    
+ *  
+ *
+ *
+ *     var keyframes = [
+ *     {
+ *       progress:0.0,
+ *       value: [0,0,0]
+ *     },
+ *     {
+ *       progress:0.25,
+ *       value: [500,0,0]
+ *     },
+ *
+ *     {
+ *       progress:0.5,
+ *       value: [500,500,0]
+ *     },
+ *     {
+ *       progress:0.75,
+ *       value: [0,500,0]
+ *     },
+ *     {
+ *       progress:1.0,
+ *       value: [0,0,0]
+ *     } ];
+ *
+ *
+ *     anim.animateBetween( imageActor,"position", keyframes );
+ *
+ */
+void AnimationApi::AnimateBetween( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Animation anim = GetAnimation( isolate, args );
+  AnimationParameters animParams( anim );
+
+  // grab all the parameters
+  bool ok = GetAnimationParameters( isolate, args, animParams, AnimationApi::KEYFRAMES );
+  if( !ok )
+  {
+    // GetAnimationParameters will log
+    return;
+  }
+
+  // if animation options exist...
+  if( animParams.optionsFound )
+  {
+
+    anim.AnimateBetween( Property( animParams.target,animParams.propertyIndex ),
+                                  animParams.keyFrames,
+                                  animParams.alphaFunction,
+                                  TimePeriod( animParams.delay, animParams.duration) );
+  }
+  else
+  {
+    anim.AnimateBetween( Property( animParams.target, animParams.propertyIndex ), animParams.keyFrames );
+  }
+}
+
+/**
+ * show an actor during the animation.
+ *
+ * This is a helper, which simulates animating the visibility property of an actor
+ * with zero duration ( it is just a boolean).
+ * e.g. it performs  anim.AnimateTo( actor,"visible",true, { delay:delay: duration:0 } );
+ * @method show
+ * @for Animation
+ * @param {Object} Actor
+ * @param {float} delay until the actor is shown
+ */
+void AnimationApi::Show( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Animation anim = GetAnimation( isolate, args );
+  bool found( false );
+
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( !found)
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 actor" );
+    return;
+  }
+  // get the duration
+  float delay = V8Utils::GetFloatParameter( PARAMETER_1, found, isolate, args, 1.f /* default */);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 1 delay" );
+    return;
+  }
+  anim.Show( actor, delay );
+
+}
+
+/**
+ * hide an actor during the animation.
+ *
+ * This is a helper, which simulates animating the visibility property of an actor
+ * with zero duration ( it is just a boolean).
+ * e.g. it performs  anim.AnimateTo( actor,"visible",false, { delay:delay: duration:0 } );
+ * @method hide
+ * @for Animation
+ * @param {Object} Actor
+ * @param {float} delay until the actor is hidden
+ */
+void AnimationApi::Hide( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Animation anim = GetAnimation( isolate, args );
+  bool found( false );
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 actor" );
+    return;
+  }
+
+  // get the duration
+  float delay = V8Utils::GetFloatParameter( PARAMETER_1, found, isolate, args, 1.f /* default */);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 1 delay" );
+    return;
+  }
+  anim.Hide( actor, delay );
+}
+
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/animation/animation-api.h b/plugins/dali-script-v8/src/animation/animation-api.h
new file mode 100644
index 0000000..8400c62
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/animation-api.h
@@ -0,0 +1,84 @@
+#ifndef __DALI_V8PLUGIN_ANIMATION_API_H__
+#define __DALI_V8PLUGIN_ANIMATION_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace AnimationApi
+{
+  /**
+   * Constructor
+   */
+  Animation New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Animation API see animation.h for a description
+   */
+  void SetDuration( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetDuration( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetLooping( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsLooping( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetEndAction( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetEndAction( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetDisconnectAction( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetDisconnectAction( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetDefaultAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetDefaultAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetCurrentProgress( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetSpeedFactor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetSpeedFactor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetPlayRange( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetPlayRange( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetCurrentProgress( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void PlayFrom( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Play( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Pause( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Stop( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Clear( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Animate( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AnimateBy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AnimateTo( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AnimateBetween( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Show( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Hide( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  enum AnimationParameterType
+  {
+    PROPERTY_VALUE,
+    KEYFRAMES
+  };
+
+}; // namespace AnimationApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_ANIMATION_API_H__
diff --git a/plugins/dali-script-v8/src/animation/animation-wrapper.cpp b/plugins/dali-script-v8/src/animation/animation-wrapper.cpp
new file mode 100644
index 0000000..d962522
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/animation-wrapper.cpp
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "animation-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+namespace V8Plugin
+{
+
+v8::Persistent AnimationWrapper::mAnimationTemplate;
+
+namespace
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction AnimationFunctionTable[]=
+{
+    /**************************************
+    * Animation API (in order of animation.h)
+    **************************************/
+
+    { "SetDuration"             , AnimationApi::SetDuration               },
+    { "GetDuration"             , AnimationApi::GetDuration               },
+    { "SetLooping"              , AnimationApi::SetLooping                },
+    { "IsLooping"               , AnimationApi::IsLooping                 },
+    { "SetEndAction"            , AnimationApi::SetEndAction              },
+    { "GetEndAction"            , AnimationApi::GetEndAction              },
+    { "SetDisconnectAction"     , AnimationApi::SetDisconnectAction       },
+    { "GetDisconnectAction"     , AnimationApi::GetDisconnectAction       },
+    { "SetDefaultAlphaFunction" , AnimationApi::SetDefaultAlphaFunction   },
+    { "GetDefaultAlphaFunction" , AnimationApi::GetDefaultAlphaFunction   },
+    { "GetCurrentProgress"      , AnimationApi::GetCurrentProgress        },
+    { "SetSpeedFactor"          , AnimationApi::SetSpeedFactor            },
+    { "GetSpeedFactor"          , AnimationApi::GetSpeedFactor            },
+    { "SetPlayRange"            , AnimationApi::SetPlayRange              },
+    { "GetPlayRange"            , AnimationApi::GetPlayRange              },
+    { "SetCurrentProgress"      , AnimationApi::SetCurrentProgress        },
+    { "Play"                    , AnimationApi::Play                      },
+    { "PlayFrom"                , AnimationApi::PlayFrom                  },
+    { "Pause"                   , AnimationApi::Pause                     },
+    { "Stop"                    , AnimationApi::Stop                      },
+    { "Clear"                   , AnimationApi::Clear                     },
+    { "Animate"                 , AnimationApi::Animate                   },
+    { "AnimateBy"               , AnimationApi::AnimateBy                 },
+    { "AnimateTo"               , AnimationApi::AnimateTo                 },
+    { "AnimateBetween"          , AnimationApi::AnimateBetween            },
+    { "Show"                    , AnimationApi::Show                      },
+    { "Hide"                    , AnimationApi::Hide                      },
+
+};
+
+const unsigned int AnimationFunctionTableCount = sizeof(AnimationFunctionTable)/sizeof(AnimationFunctionTable[0]);
+} //un-named space
+
+
+AnimationWrapper::AnimationWrapper( const Dali::Animation& animation, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::ANIMATION , gc )
+{
+    mAnimation = animation;
+}
+
+AnimationWrapper::~AnimationWrapper()
+{
+
+}
+
+v8::Handle AnimationWrapper::WrapAnimation(v8::Isolate* isolate, const Dali::Animation& animation )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetAnimationTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the Animation wrapper
+  AnimationWrapper* pointer =  new AnimationWrapper( animation, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local AnimationWrapper::GetAnimationTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  if( mAnimationTemplate.IsEmpty() )
+  {
+    objectTemplate = MakeAnimationTemplate( isolate );
+    mAnimationTemplate.Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, mAnimationTemplate );
+  }
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle AnimationWrapper::MakeAnimationTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  // add intercepts for Signals, we can't use HandleWrapper::AddIntercepts because Animation doesn't inherit
+  // from Handle ( just baseHandle)
+  ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, AnimationFunctionTable, AnimationFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+void AnimationWrapper::NewAnimation( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if( !args.IsConstructCall() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Animation constructor called without 'new'" );
+    return;
+  }
+
+  Dali::Animation animation = AnimationApi::New( args );
+  v8::Local localObject = WrapAnimation( isolate, animation );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+Animation AnimationWrapper::GetAnimation()
+{
+  return mAnimation;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/animation/animation-wrapper.h b/plugins/dali-script-v8/src/animation/animation-wrapper.h
new file mode 100644
index 0000000..469736c
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/animation-wrapper.h
@@ -0,0 +1,82 @@
+#ifndef __DALI_V8PLUGIN_ANIMATION_WRAPPER_H__
+#define __DALI_V8PLUGIN_ANIMATION_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * Animation  wrapper.
+ * Provides access to Animation specific functionality
+ */
+class AnimationWrapper : public BaseWrappedObject
+{
+
+public:
+
+  AnimationWrapper( const Animation& animation,
+                GarbageCollectorInterface& gc );
+
+  virtual ~AnimationWrapper();
+
+  /**
+   * @brief Creates a new Animation wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewAnimation( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps an animation
+   */
+  static v8::Handle WrapAnimation(v8::Isolate* isolate, const Dali::Animation& );
+
+
+  // The AnimationAttribute ObjectTemplate, we cache templates so we don't have
+  // keep generating them everytime we want to create an Animation
+  static v8::Persistent mAnimationTemplate;
+
+  Animation GetAnimation();
+  virtual SignalManager* GetSignalManager() { return &mSignalManager;}
+
+private:
+
+  Animation mAnimation;           ///< animation object
+  SignalManager mSignalManager;   ///< signal manager
+
+  static v8::Handle MakeAnimationTemplate( v8::Isolate* isolate );
+  static v8::Local GetAnimationTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_ANIMATION_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/animation/path-api.cpp b/plugins/dali-script-v8/src/animation/path-api.cpp
new file mode 100644
index 0000000..95dba63
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/path-api.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "path-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+Path GetPath( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField( 0 ) );
+  void* ptr = field->Value();
+
+  PathWrapper* wrapper = static_cast( ptr );
+  return wrapper->GetPath();
+}
+
+} // un-named namespace
+
+
+/**
+ * Automatic generation of control points. Generated control points which result in a smooth join between the splines of each segment.
+ *
+ * The generating algorithm is as follows:
+ * For a given knot point K[N], find the vector that bisects K[N-1],[N] and [N],[N+1].
+ * Calculate the tangent vector by taking the normal of this bisector.
+ * The in control point is the length of the preceding segment back along this bisector multiplied by the curvature
+ * The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature
+ *
+ * @method generateControlPoints
+ * @for Path
+ * @param {float} curvature curvature The curvature of the spline. 0 gives straight lines between the knots,
+ * negative values means the spline contains loops, positive values up to
+ * 0.5 result in a smooth curve, positive values between 0.5 and 1 result
+ * in looped curves where the loops are not distinct (i.e. the curve appears
+ * to be non-continuous), positive values higher than 1 result in looped curves.
+ */
+void PathApi::GenerateControlPoints( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  float curvature = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 1.0f /* default */);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+
+  Path path = GetPath( isolate, args );
+  path.GenerateControlPoints( curvature );
+}
+
+
+/**
+ * Add a interpolation point.
+ * @method addPoint
+ * @for Path
+ * @param {Vector3} interpolationPoint The new interpolation point to be added
+ * @example
+ *        path.addPoint([ 10,40,0] );
+ */
+void PathApi::AddPoint( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  Vector3 value = V8Utils::GetVector3Parameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+
+  Path path = GetPath( isolate, args );
+  path.AddPoint( value );
+}
+
+
+/**
+ * Add a control point.
+ * @method addControlPoint
+ * @for Path
+ * @param {Vector3} controlPoint The new control point to be added
+ * @example
+ *        path.addControlPoint([ 10,40,0] );
+ */
+void PathApi::AddControlPoint( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  Vector3 value = V8Utils::GetVector3Parameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+
+  Path path = GetPath( isolate, args );
+  path.AddControlPoint( value );
+}
+
+/**
+ * Sample path at a given progress. Calculates position and tangent at that point of the curve
+ * @method sample
+ * @for Path
+ * @param {float} Progress  A floating point value between 0.0 and 1.0.
+ * @return {Object} { position: Vector3, tangent:Vector3 }
+ */
+void PathApi::Sample( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  float progress = V8Utils::GetFloatParameter( PARAMETER_0, found, isolate, args, 0.0f /* default */);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+    return;
+  }
+
+  //Sample the path
+  Path path = GetPath( isolate, args );
+  Vector3 position, tangent;
+  path.Sample( progress, position, tangent );
+
+  //Create v8 object with the result
+  v8::Local sampleObject = v8::Object::New( isolate );
+
+  Dali::Property::Value valuePosition( position );
+  sampleObject->Set( v8::String::NewFromUtf8( isolate, "position"), PropertyValueWrapper::WrapDaliProperty( isolate, valuePosition));
+
+  Dali::Property::Value valueTangent( tangent );
+  sampleObject->Set( v8::String::NewFromUtf8( isolate, "tangent"), PropertyValueWrapper::WrapDaliProperty( isolate, valueTangent));
+
+  args.GetReturnValue().Set( sampleObject );
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/animation/path-api.h b/plugins/dali-script-v8/src/animation/path-api.h
new file mode 100644
index 0000000..8fb7c47
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/path-api.h
@@ -0,0 +1,50 @@
+#ifndef __DALI_V8PLUGIN_PATH_API_H__
+#define __DALI_V8PLUGIN_PATH_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace PathApi
+{
+  /**
+   * Path API see path.h for a description
+   */
+  void GenerateControlPoints( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AddPoint( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AddControlPoint( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Sample( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace PathApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_PATH_API_H__
diff --git a/plugins/dali-script-v8/src/animation/path-wrapper.cpp b/plugins/dali-script-v8/src/animation/path-wrapper.cpp
new file mode 100644
index 0000000..b89179f
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/path-wrapper.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "path-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+
+const ApiFunction PathFunctions[]=
+{
+ { "GenerateControlPoints",  PathApi::GenerateControlPoints },
+ { "AddPoint",               PathApi::AddPoint },
+ { "AddControlPoint",        PathApi::AddControlPoint },
+ { "Sample",                 PathApi::Sample }
+};
+
+const unsigned int PathFunctionTableCount = sizeof(PathFunctions)/sizeof(PathFunctions[0]);
+} //un-named space
+
+
+PathWrapper::PathWrapper( Path path, GarbageCollectorInterface& gc )
+:HandleWrapper( BaseWrappedObject::PATH, path, gc ),
+ mPath( path )
+{
+}
+
+v8::Handle PathWrapper::MakePathTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, PathFunctions, PathFunctionTableCount );
+
+  // property handle intercepts property getters and setters and signals
+  HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
+
+  return handleScope.Escape( objTemplate );
+}
+
+v8::Handle PathWrapper::WrapPath( v8::Isolate* isolate, Path path )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = MakePathTemplate( isolate );
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create teh actor object
+  PathWrapper* pointer = new PathWrapper( path, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  // This also stores Dali object, in an internal field inside the JavaScript object.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+Path PathWrapper::GetPath()
+{
+  return mPath;
+}
+
+/**
+ * Create an initialized Path handle.
+ * @constructor
+ * @for Path
+ * @method Path
+ */
+void PathWrapper::NewPath( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  if( !args.IsConstructCall() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "constructor called without 'new" );
+    return;
+  }
+
+  // Create a new path
+  Path path = Path::New();
+  v8::Local localObject = WrapPath( isolate, path );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/animation/path-wrapper.h b/plugins/dali-script-v8/src/animation/path-wrapper.h
new file mode 100644
index 0000000..d6c42b6
--- /dev/null
+++ b/plugins/dali-script-v8/src/animation/path-wrapper.h
@@ -0,0 +1,83 @@
+#ifndef __DALI_V8PLUGIN_PATH_WRAPPER_H__
+#define __DALI_V8PLUGIN_PATH_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * Wraps a Path.
+ */
+class PathWrapper : public HandleWrapper
+{
+
+public:
+
+  /**
+   * Constructor
+   */
+  PathWrapper( Path path, GarbageCollectorInterface& gc );
+
+  /**
+   * Virtual destructor
+   */
+  virtual ~PathWrapper(){};
+
+  /**
+   * Creates a new Path wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewPath( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps a path inside a Javascript object
+   */
+  static v8::Handle WrapPath(v8::Isolate* isolate, Path path );
+
+  /*
+   * Get the wrapped path
+   */
+  Path GetPath();
+
+private:
+
+  /**
+   * Create a v8 object template for the path
+   */
+  static v8::Handle MakePathTemplate( v8::Isolate* isolate );
+
+  Path mPath;
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/constants/constants-wrapper.cpp b/plugins/dali-script-v8/src/constants/constants-wrapper.cpp
new file mode 100644
index 0000000..1124956
--- /dev/null
+++ b/plugins/dali-script-v8/src/constants/constants-wrapper.cpp
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "constants-wrapper.h"
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+
+struct Vector3Pair
+{
+  const char* name;
+  const Vector3& value;
+};
+
+struct Vector4Pair
+{
+  const char* name;
+  const Vector4& value;
+};
+
+struct IntegerPair
+{
+  const char* name;
+  const int value;
+};
+
+
+const Vector3Pair Vector3Table[] =
+{
+    { "BACK_TOP_LEFT"      , ParentOrigin::BACK_TOP_LEFT      },
+    { "BACK_TOP_CENTER"    , ParentOrigin::BACK_TOP_CENTER    },
+    { "BACK_TOP_RIGHT"     , ParentOrigin::BACK_TOP_RIGHT     },
+    { "BACK_CENTER_LEFT"   , ParentOrigin::BACK_CENTER_LEFT   },
+    { "BACK_CENTER"        , ParentOrigin::BACK_CENTER        },
+    { "BACK_CENTER_RIGHT"  , ParentOrigin::BACK_CENTER_RIGHT  },
+    { "BACK_BOTTOM_LEFT"   , ParentOrigin::BACK_BOTTOM_LEFT   },
+    { "BACK_BOTTOM_CENTER" , ParentOrigin::BACK_BOTTOM_CENTER },
+    { "BACK_BOTTOM_RIGHT"  , ParentOrigin::BACK_BOTTOM_RIGHT  },
+
+    { "TOP_LEFT"            , ParentOrigin::TOP_LEFT          },
+    { "TOP_CENTER"          , ParentOrigin::TOP_CENTER        },
+    { "TOP_RIGHT"           , ParentOrigin::TOP_RIGHT         },
+    { "CENTER_LEFT"         , ParentOrigin::CENTER_LEFT       },
+    { "CENTER"              , ParentOrigin::CENTER            },
+    { "CENTER_RIGHT"        , ParentOrigin::CENTER_RIGHT      },
+    { "BOTTOM_LEFT"         , ParentOrigin::BOTTOM_LEFT       },
+    { "BOTTOM_CENTER"       , ParentOrigin::BOTTOM_CENTER     },
+    { "BOTTOM_RIGHT"        , ParentOrigin::BOTTOM_RIGHT      },
+
+    { "FRONT_TOP_LEFT"      , ParentOrigin::FRONT_TOP_LEFT     },
+    { "FRONT_TOP_CENTER"    , ParentOrigin::FRONT_TOP_CENTER   },
+    { "FRONT_TOP_RIGHT"     , ParentOrigin::FRONT_TOP_RIGHT    },
+    { "FRONT_CENTER_LEFT"   , ParentOrigin::FRONT_CENTER_LEFT  },
+    { "FRONT_CENTER"        , ParentOrigin::FRONT_CENTER       },
+    { "FRONT_CENTER_RIGHT"  , ParentOrigin::FRONT_CENTER_RIGHT },
+    { "FRONT_BOTTOM_LEFT"   , ParentOrigin::FRONT_BOTTOM_LEFT  },
+    { "FRONT_BOTTOM_CENTER" , ParentOrigin::FRONT_BOTTOM_CENTER},
+    { "FRONT_BOTTOM_RIGHT"  , ParentOrigin::FRONT_BOTTOM_RIGHT },
+
+
+    { "VECTOR3_ONE"                  ,      Vector3::ONE                        },
+    { "VECTOR3_XAXIS"                ,      Vector3::XAXIS                      },
+    { "VECTOR3_YAXIS"                ,      Vector3::YAXIS                      },
+    { "VECTOR3_ZAXIS"                ,      Vector3::ZAXIS                      },
+    { "VECTOR3_NEGATIVE_XAXIS"       ,      Vector3::NEGATIVE_XAXIS             },
+    { "VECTOR3_NEGATIVE_YAXIS"       ,      Vector3::NEGATIVE_YAXIS             },
+    { "VECTOR3_NEGATIVE_ZAXIS"       ,      Vector3::NEGATIVE_ZAXIS             },
+    { "VECTOR3_ZERO"                 ,      Vector3::ZERO                       }
+
+
+};
+
+const unsigned int Vector3TableCount = sizeof(Vector3Table)/sizeof(Vector3Table[0]);
+
+const Vector4Pair Vector4Table[] =
+{
+    { "COLOR_BLACK"                  , Color::BLACK       },
+    { "COLOR_WHITE"                  , Color::WHITE       },
+    { "COLOR_RED"                    , Color::RED         },
+    { "COLOR_GREEN"                  , Color::GREEN       },
+    { "COLOR_BLUE"                   , Color::BLUE        },
+    { "COLOR_YELLOW"                 , Color::YELLOW      },
+    { "COLOR_MAGENTA"                , Color::MAGENTA     },
+    { "COLOR_CYAN"                   , Color::CYAN        },
+    { "COLOR_TRANSPARENT"            , Color::TRANSPARENT }
+
+};
+
+const unsigned int Vector4TableCount = sizeof(Vector4Table)/sizeof(Vector4Table[0]);
+
+const IntegerPair EnumTable[] =
+{
+
+    { "ANIMATION_BAKE",                                       Animation::Bake                    },
+    { "ANIMATION_DISCARD",                                    Animation::Discard                 },
+    { "ANIMATION_BAKE_FINAL",                                 Animation::BakeFinal               },
+    { "REFRESH_ONCE",                                         RenderTask::REFRESH_ONCE           },
+    { "REFRESH_ALWAYS",                                       RenderTask::REFRESH_ALWAYS         },
+
+    { "PIXEL_FORMAT_A8",                                       Pixel::A8,                        },
+    { "PIXEL_FORMAT_L8",                                       Pixel::L8,                        },
+    { "PIXEL_FORMAT_LA88",                                     Pixel::LA88,                      },
+    { "PIXEL_FORMAT_RGB565",                                   Pixel::RGB565,                    },
+    { "PIXEL_FORMAT_BGR565",                                   Pixel::BGR565,                    },
+    { "PIXEL_FORMAT_RGBA4444",                                 Pixel::RGBA4444,                  },
+    { "PIXEL_FORMAT_BGRA4444",                                 Pixel::BGRA4444,                  },
+    { "PIXEL_FORMAT_RGBA5551",                                 Pixel::RGBA5551,                   },
+    { "PIXEL_FORMAT_BGRA5551",                                 Pixel::BGRA5551,                  },
+    { "PIXEL_FORMAT_RGB888",                                   Pixel::RGB888,                    },
+    { "PIXEL_FORMAT_RGB8888",                                  Pixel::RGB8888,                   },
+    { "PIXEL_FORMAT_BGR8888",                                  Pixel::BGR8888,                   },
+    { "PIXEL_FORMAT_RGBA8888",                                 Pixel::RGBA8888,                  },
+    { "PIXEL_FORMAT_BGRA8888",                                 Pixel::BGRA8888,                  },
+
+    { "PIXEL_FORMAT_COMPRESSED_R11_EAC",                       Pixel::COMPRESSED_R11_EAC,        },
+    { "PIXEL_FORMAT_COMPRESSED_SIGNED_R11_EAC",                Pixel::COMPRESSED_SIGNED_R11_EAC,                },
+    { "PIXEL_FORMAT_COMPRESSED_RG11_EAC",                      Pixel::COMPRESSED_RG11_EAC,                      },
+    { "PIXEL_FORMAT_COMPRESSED_SIGNED_RG11_EAC",               Pixel::COMPRESSED_SIGNED_RG11_EAC,               },
+    { "PIXEL_FORMAT_COMPRESSED_RGB8_ETC2",                     Pixel::COMPRESSED_RGB8_ETC2,                     },
+    { "PIXEL_FORMAT_COMPRESSED_SRGB8_ETC2",                    Pixel::COMPRESSED_SRGB8_ETC2,                    },
+    { "PIXEL_FORMAT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, },
+    { "PIXEL_FORMAT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2",Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2},
+    { "PIXEL_FORMAT_COMPRESSED_RGBA8_ETC2_EAC",                Pixel::COMPRESSED_RGBA8_ETC2_EAC,                },
+    { "PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC",         Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,         },
+    { "PIXEL_FORMAT_COMPRESSED_RGB8_ETC1",                     Pixel::COMPRESSED_RGB8_ETC1,                     },
+    { "PIXEL_FORMAT_COMPRESSED_RGB_PVRTC_4BPPV1",              Pixel::COMPRESSED_RGB_PVRTC_4BPPV1               },
+
+
+    { "COLOR_MODE_USE_OWN_COLOR",                              USE_OWN_COLOR                    },
+    { "COLOR_MODE_USE_PARENT_COLOR",                           USE_PARENT_COLOR                 },
+    { "COLOR_MODE_USE_OWN_MULTIPLY_PARENT_COLOR",              USE_OWN_MULTIPLY_PARENT_COLOR    },
+    { "COLOR_MODE_USE_OWN_MULTIPLY_PARENT_ALPHA",              USE_OWN_MULTIPLY_PARENT_ALPHA    },
+
+
+    { "POSITION_INHERITANCE_INHERIT_PARENT_POSITION",                    INHERIT_PARENT_POSITION                    },
+    { "POSITION_INHERITANCE_USE_PARENT_POSITION",                        USE_PARENT_POSITION                        },
+    { "POSITION_INHERITANCE_USE_PARENT_POSITION_PLUS_LOCAL_POSITION",    USE_PARENT_POSITION_PLUS_LOCAL_POSITION    },
+    { "POSITION_INHERITANCE_DONT_INHERIT_POSITION",                      DONT_INHERIT_POSITION                      },
+
+    { "DRAW_MODE_NORMAL",                                   DrawMode::NORMAL     },
+    { "DRAW_MODE_OVERLAY",                                  DrawMode::OVERLAY    },
+    { "DRAW_MODE_STENCIL",                                  DrawMode::STENCIL    },
+
+    { "IMAGE_LOAD_POLICY_IMMEDIATE",                        ResourceImage::IMMEDIATE },
+    { "IMAGE_LOAD_POLICY_ON_DEMAND",                        ResourceImage::ON_DEMAND  },
+
+    { "IMAGE_RELEASE_POLICY_UNUSED",                        Image::UNUSED },
+    { "IMAGE_RELEASE_POLICY_NEVER",                         Image::NEVER  },
+
+    { "RESOURCE_LOADING",                                   Dali::ResourceLoading },
+    { "RESOURCE_LOADING_SUCCEEDED",                         Dali::ResourceLoadingSucceeded  },
+    { "RESOUCE_LOADING_FAILED",                             Dali::ResourceLoadingFailed  },
+
+
+
+
+    { "BLEND_FACTOR_ZERO",                                  BlendingFactor::ZERO                    },
+    { "BLEND_FACTOR_ONE",                                   BlendingFactor::ONE                     },
+    { "BLEND_FACTOR_SRC_COLOR",                             BlendingFactor::SRC_COLOR               },
+    { "BLEND_FACTOR_ONE_MINUS_SRC_COLOR",                   BlendingFactor::ONE_MINUS_SRC_COLOR     },
+    { "BLEND_FACTOR_SRC_ALPHA",                             BlendingFactor::SRC_ALPHA               },
+    { "BLEND_FACTOR_ONE_MINUS_SRC_ALPHA",                   BlendingFactor::ONE_MINUS_SRC_ALPHA     },
+    { "BLEND_FACTOR_DST_ALPHA",                             BlendingFactor::DST_ALPHA                },
+    { "BLEND_FACTOR_ONE_MINUS_DST_ALPHA",                   BlendingFactor::ONE_MINUS_DST_ALPHA      },
+    { "BLEND_FACTOR_DST_COLOR",                             BlendingFactor::DST_COLOR                },
+    { "BLEND_FACTOR_ONE_MINUS_DST_COLOR",                   BlendingFactor::ONE_MINUS_DST_COLOR      },
+    { "BLEND_FACTOR_SRC_ALPHA_SATURATE",                    BlendingFactor::SRC_ALPHA_SATURATE       },
+    { "BLEND_FACTOR_CONSTANT_COLOR",                        BlendingFactor::CONSTANT_COLOR           },
+    { "BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR",              BlendingFactor::ONE_MINUS_CONSTANT_COLOR },
+    { "BLEND_FACTOR_CONSTANT_ALPHA" ,                       BlendingFactor::CONSTANT_ALPHA           },
+    { "BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA",              BlendingFactor::ONE_MINUS_CONSTANT_ALPHA },
+
+    { "BLENDING_OFF",                                      BlendingMode::OFF             },
+    { "BLENDING_AUTO",                                     BlendingMode::AUTO            },
+    { "BLENDING_ON",                                       BlendingMode::ON              },
+
+    { "BLEND_EQUATION_ADD",                                BlendingEquation::ADD              },
+    { "BLEND_EQUATION_SUBTRACT",                           BlendingEquation::SUBTRACT         },
+    { "BLEND_EQUATION_REVERSE_SUBTRACT",                   BlendingEquation::REVERSE_SUBTRACT },
+
+
+    { "CULL_FACE_DISABLE",                                  CullNone  },
+    { "CULL_FRONT_FACE",                                    CullFront },
+    { "CULL_BACK_FACE",                                     CullBack  },
+    { "CULL_FRONT_AND_BACK_FACE",                           CullFrontAndBack },
+
+    { "USE_OWN_SIZE",                                       USE_OWN_SIZE },
+    { "SIZE_EQUAL_TO_PARENT",                               SIZE_EQUAL_TO_PARENT },
+    { "SIZE_RELATIVE_TO_PARENT",                            SIZE_RELATIVE_TO_PARENT },
+    { "SIZE_FIXED_OFFSET_FROM_PARENT",                      SIZE_FIXED_OFFSET_FROM_PARENT },
+
+    { "CAMERA_FREE_LOOK"             ,      Camera::FREE_LOOK                   },
+    { "CAMERA_LOOK_AT_TARGET"        ,      Camera::LOOK_AT_TARGET              },
+    { "CAMERA_PERSPECTIVE_PROJECTION" ,     Camera::PERSPECTIVE_PROJECTION      },
+    { "CAMERA_ORTHOGRAPHIC_PROJECTION",     Camera::ORTHOGRAPHIC_PROJECTION     },
+
+    {"IMAGE_ACTOR_STYLE_QUAD",                ImageActor::STYLE_QUAD},
+    {"IMAGE_ACTOR_STYLE_NINE_PATCH",          ImageActor::STYLE_NINE_PATCH},
+    {"IMAGE_ACTOR_STYLE_NINE_PATCH_NO_CENTER",ImageActor::STYLE_NINE_PATCH_NO_CENTER }
+
+
+};
+const unsigned int EnumTableCount = sizeof(EnumTable)/sizeof(EnumTable[0]);
+
+
+
+
+
+
+} // un-named name space
+
+
+void ConstantsWrapper::AddDaliConstants( v8::Isolate* isolate, v8::Local& obj  )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+
+  for( unsigned int i = 0; i < EnumTableCount; ++i )
+  {
+    obj->Set( v8::String::NewFromUtf8( isolate, EnumTable[i].name ),
+                      v8::Integer::New(isolate, EnumTable[i].value ) );
+  }
+
+  for( unsigned int i = 0; i < Vector3TableCount; ++i )
+  {
+    // create a JavaScript array object with 3 entries.
+    v8::Local array = v8::Array::New( isolate ,3 );
+    array->Set( 0 , v8::Number::New(isolate, Vector3Table[i].value.x ));
+    array->Set( 1 , v8::Number::New(isolate, Vector3Table[i].value.y ));
+    array->Set( 2 , v8::Number::New(isolate, Vector3Table[i].value.z ));
+
+    obj->Set( v8::String::NewFromUtf8( isolate, Vector3Table[i].name),
+              array);
+  }
+
+
+  for( unsigned int i = 0; i < Vector4TableCount; ++i )
+  {
+    // create a JavaScript array object with 3 entries.
+    v8::Local array = v8::Array::New( isolate ,4 );
+    array->Set( 0 , v8::Number::New(isolate, Vector4Table[i].value.x ));
+    array->Set( 1 , v8::Number::New(isolate, Vector4Table[i].value.y ));
+    array->Set( 2 , v8::Number::New(isolate, Vector4Table[i].value.z ));
+    array->Set( 3 , v8::Number::New(isolate, Vector4Table[i].value.w ));
+
+    obj->Set( v8::String::NewFromUtf8( isolate, Vector4Table[i].name),
+              array);
+  }
+
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/constants/constants-wrapper.h b/plugins/dali-script-v8/src/constants/constants-wrapper.h
new file mode 100644
index 0000000..9e25e6a
--- /dev/null
+++ b/plugins/dali-script-v8/src/constants/constants-wrapper.h
@@ -0,0 +1,39 @@
+#ifndef __DALI_V8PLUGIN_DALI_CONSTANTS_WRAPPER
+#define __DALI_V8PLUGIN_DALI_CONSTANTS_WRAPPER
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace  ConstantsWrapper
+{
+
+void AddDaliConstants( v8::Isolate* isolate, v8::Local& obj  );
+} // namespace ConstantsWrapper
+
+} // namespace V8Plugin
+
+} // namespace Dali
+#endif
diff --git a/plugins/dali-script-v8/src/dali-script-v8.cpp b/plugins/dali-script-v8/src/dali-script-v8.cpp
new file mode 100644
index 0000000..4467b0a
--- /dev/null
+++ b/plugins/dali-script-v8/src/dali-script-v8.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#include "dali-script-v8.h"
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+// The plugin factories
+extern "C" DALI_EXPORT_API Dali::Toolkit::ScriptPlugin* CreateScriptPlugin(void)
+{
+  return new Dali::V8Plugin::DaliScriptV8;
+}
+
+extern "C" DALI_EXPORT_API void DestroyScriptPlugin(Dali::Toolkit::ScriptPlugin* plugin)
+{
+  delete plugin;
+}
+
+namespace Dali
+{
+namespace V8Plugin
+{
+
+DaliScriptV8::DaliScriptV8()
+{
+}
+
+DaliScriptV8::~DaliScriptV8()
+{
+  DaliWrapper::Get().Shutdown();
+}
+
+void DaliScriptV8::SetFlags(const std::string& s)
+{
+  DaliWrapper::Get().SetFlagsFromString(s);
+}
+
+void DaliScriptV8::ExecuteBuffer(const std::string& buffer, const std::string& filename)
+{
+  DaliWrapper::Get().ExecuteBuffer(buffer, filename);
+}
+
+void DaliScriptV8::ExecuteFile(const std::string& filename)
+{
+
+
+  DaliWrapper::Get().ExecuteFile( filename );
+}
+
+}  // namespace V8Plugin
+
+}  // namespace Dali
+
diff --git a/plugins/dali-script-v8/src/dali-script-v8.h b/plugins/dali-script-v8/src/dali-script-v8.h
new file mode 100644
index 0000000..4a1e891
--- /dev/null
+++ b/plugins/dali-script-v8/src/dali-script-v8.h
@@ -0,0 +1,72 @@
+#ifndef __DALI_V8PLUGIN_SCRIPT_H__
+#define __DALI_V8PLUGIN_SCRIPT_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali DALI_IMPORT_API
+{
+
+namespace V8Plugin
+{
+
+/**
+ * Executes JavaScript V8 scripts
+ */
+class  DaliScriptV8 : public Dali::Toolkit::ScriptPlugin
+{
+public: // Construction & Destruction
+
+  /**
+   * Constructor
+   */
+  DaliScriptV8();
+
+  /**
+   * Destructor
+   */
+  virtual ~DaliScriptV8();
+
+public: // ScriptV8Plugin overrides
+
+  /**
+   * @copydoc Dali::Toolkit::ScriptPlugin::SetFlags()
+   */
+  virtual void SetFlags(const std::string& s);
+
+  /**
+   * @copydoc Dali::Toolkit::ScriptPlugin::ExecuteBuffer()
+   */
+  virtual void ExecuteBuffer(const std::string& buffer, const std::string& filename);
+
+  /**
+   * @copydoc Dali::Toolkit::ScriptPlugin::ExecuteFile()
+   */
+  virtual void ExecuteFile(const std::string& fileName);
+
+
+};
+
+}  // namespace V8Plugin
+
+}  // namespace Dali
+
+#endif // __FEEDBACK_PLUGIN_H__
diff --git a/plugins/dali-script-v8/src/dali-wrapper.cpp b/plugins/dali-script-v8/src/dali-wrapper.cpp
new file mode 100644
index 0000000..55df482
--- /dev/null
+++ b/plugins/dali-script-v8/src/dali-wrapper.cpp
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "dali-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+/**
+ * This string defines how the global DALi object/namespace is used from JavaScript
+ * E.g. new dali.Image or dali.stage.add( )
+ */
+const char* const DALI_API_NAME = "dali";
+
+/**
+ * lookup table for setting up function calls for creating Dali objects
+ * e.g.  new dali.TextActor()
+ */
+const ApiFunction ConstructorFunctionTable[]=
+{
+    { "Rotation",           PropertyValueWrapper::NewRotation},
+    { "Matrix",             PropertyValueWrapper::NewMatrix},
+    { "Font",               FontWrapper::NewFont },
+    { "Path",               PathWrapper::NewPath },
+    { "Actor",              ActorWrapper::NewActor },
+    { "TextActor",          ActorWrapper::NewActor },
+    { "ImageActor",         ActorWrapper::NewActor },
+    { "MeshActor",          ActorWrapper::NewActor },
+    { "CameraActor",        ActorWrapper::NewActor },
+    { "Layer",              ActorWrapper::NewActor },
+    { "TextView",           ActorWrapper::NewActor },
+    { "ResourceImage",      ImageWrapper::NewImage },
+    { "BufferImage",        ImageWrapper::NewImage },
+    { "NinePatchImage",     ImageWrapper::NewImage },
+    { "FrameBufferImage",   ImageWrapper::NewImage },
+    { "ImageAttributes",    ImageAttributesWrapper::NewImageAttributes },
+    { "Animation",          AnimationWrapper::NewAnimation},
+    { "ShaderEffect",       ShaderEffectWrapper::NewShaderEffect},
+    { "Builder",            BuilderWrapper::NewBuilder},
+    { "PanGestureDetector", PanGestureDetectorWrapper::NewPanGestureDetector},
+
+};
+
+const unsigned int PropertyFunctionTableCount = sizeof(ConstructorFunctionTable)/sizeof(ConstructorFunctionTable[0]);
+
+void FatalErrorCallback(const char* location, const char* message)
+{
+  DALI_LOG_ERROR("%s, %s \n",location,message);
+  DALI_ASSERT_ALWAYS( 0 && "V8 fatal error");
+}
+
+#if defined(DEBUG_ENABLED)
+// default to verbose logging
+Integration::Log::Filter* gLogExecuteFilter( Integration::Log::Filter::New(Debug::Verbose, false, "EXECUTE_JAVASCRIPT") );
+#endif
+} // un-named name space
+
+
+
+bool DaliWrapper::mInstanceCreated = false;
+DaliWrapper* DaliWrapper::mWrapper = NULL;
+
+DaliWrapper::DaliWrapper()
+:mIsolate( NULL )
+{
+}
+
+DaliWrapper::~DaliWrapper()
+{
+  mInstanceCreated = false;
+}
+
+DaliWrapper& DaliWrapper::Get()
+{
+  if(!mInstanceCreated)
+  {
+    mWrapper = new DaliWrapper();
+    mInstanceCreated = true;
+
+    if(mWrapper)
+    {
+      mWrapper->Initialize();
+    }
+  }
+
+  return *mWrapper;
+}
+
+void DaliWrapper::SetFlagsFromString(const std::string &flags)
+{
+  v8::V8::SetFlagsFromString(flags.c_str(), flags.size());
+}
+
+void DaliWrapper::Shutdown()
+{
+  DALI_LOG_WARNING("Destroying V8 DALi context\n");
+
+  if( !mContext.IsEmpty())
+  {
+    v8::HandleScope handleScope( mIsolate );
+    v8::Local context = v8::Local::New(mIsolate, mContext);
+    context->Exit();   // exit the context
+    mContext.Reset();  // destroys the context
+  }
+}
+
+void DaliWrapper::ExecuteBuffer(const std::string &sourceCode, const std::string &sourceFileName)
+{
+  mModuleLoader.ExecuteScript( mIsolate,  sourceCode, sourceFileName );
+}
+
+void DaliWrapper::ExecuteFile( const std::string& sourceFileName )
+{
+  DALI_LOG_INFO( gLogExecuteFilter, Debug::Verbose, "Executing source file %s \n",sourceFileName.c_str() );
+
+  mModuleLoader.ExecuteScriptFromFile( mIsolate,  sourceFileName );
+}
+
+GarbageCollectorInterface& DaliWrapper::GetDaliGarbageCollector()
+{
+  return mGarbageCollector;
+}
+
+void DaliWrapper::CreateContext( )
+{
+  v8::HandleScope handleScope( mIsolate );
+
+  // Create a  global JavaScript object so we can set built-in global functions, like Log.
+  v8::Handle global = v8::ObjectTemplate::New( mIsolate );
+
+  // Add global objects ( functions/ values ) e.g. log function and V8_VERSION
+  global->Set( v8::String::NewFromUtf8( mIsolate,  "log"),        v8::FunctionTemplate::New( mIsolate, V8Utils::Log) );
+  global->Set( v8::String::NewFromUtf8( mIsolate,  "logError"),   v8::FunctionTemplate::New( mIsolate, V8Utils::LogError) );
+  global->Set( v8::String::NewFromUtf8( mIsolate,  "require"),    v8::FunctionTemplate::New( mIsolate, DaliWrapper::Require));
+  global->Set( v8::String::NewFromUtf8( mIsolate,  "V8_VERSION") ,v8::String::NewFromUtf8( mIsolate, v8::V8::GetVersion() ));
+
+   // add the dali object to it, assume it won't be garbage collected until global is deleted
+  global->Set(v8::String::NewFromUtf8( mIsolate, DALI_API_NAME) ,  NewDaliObjectTemplate( mIsolate ));
+
+
+  // create a new context.
+  // Isolate = isolated copy of the V8 including a heap manager, a garbage collector
+  // Only 1 thread can access a single Isolate at a given time. However, multiple Isolates can be run in parallel.
+  // Context = multiple contexts can exist in a given Isolate, and share data between contexts
+  v8::Handle context  = v8::Context::New( mIsolate, NULL, global);
+
+  mGlobalObjectTemplate.Reset( mIsolate,  global); 
+
+  mContext.Reset( mIsolate, context);
+}
+
+void DaliWrapper::Initialize()
+{
+  if( !mIsolate )
+  {
+    v8::V8::Initialize();
+    v8::V8::InitializeICU();
+    v8::V8::SetFatalErrorHandler( FatalErrorCallback );
+    mIsolate = v8::Isolate::GetCurrent();
+  }
+  // if context is null, create it and add dali object to the global object.
+  if( mContext.IsEmpty())
+  {
+     v8::HandleScope handleScope( mIsolate );
+     CreateContext();
+     v8::Local context = v8::Local::New(mIsolate, mContext);
+
+     context->Enter();
+
+     // Add the dali global object. Used for creating objects, and accessing constant values
+     // e.g. var x =  new dali.ImageActor(), or var col = dali.COLOR_RED;
+
+     v8::Local daliObject = v8::Local::Cast( context->Global()->Get( v8::String::NewFromUtf8( mIsolate, DALI_API_NAME)));
+
+     v8::Local stageObject = StageWrapper::WrapStage( mIsolate, Stage::GetCurrent() );
+     daliObject->Set( v8::String::NewFromUtf8( mIsolate, "stage") , stageObject );
+
+     // fontObject provides static font functionality like GetFontList...
+     v8::Local fontObject = FontWrapper::GetStaticFontObject( mIsolate );
+     daliObject->Set( v8::String::NewFromUtf8( mIsolate, "font") , fontObject );
+
+     // keyboard focus manager is a singleton
+     v8::Local keyboardObject = KeyboardFocusManagerWrapper::WrapKeyboardFocusManager( mIsolate,Toolkit::KeyboardFocusManager::Get() );
+     daliObject->Set( v8::String::NewFromUtf8( mIsolate, "keyboardFocusManager") , keyboardObject );
+
+     ConstantsWrapper::AddDaliConstants( mIsolate, daliObject);
+
+  }
+  DALI_LOG_INFO( gLogExecuteFilter, Debug::Verbose, "V8 Library %s loaded \n", v8::V8::GetVersion() );
+}
+
+v8::Handle DaliWrapper::NewDaliObjectTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  // create the template
+  v8::Local< v8::ObjectTemplate > objTemplate = v8::ObjectTemplate::New( isolate );
+
+  // Add some value properties ( a property can be a primitive value, an object or a function).
+  objTemplate->Set( v8::String::NewFromUtf8( isolate, "BUILD"),
+                    v8::String::NewFromUtf8( isolate, "Dali binary built on:" __DATE__ ", at " __TIME__));
+
+
+  // add the data data directory,
+  objTemplate->Set( v8::String::NewFromUtf8( isolate, "DALI_DATA_DIRECTORY"),
+                      v8::String::NewFromUtf8( isolate, DALI_DATA_READ_ONLY_DIR));
+
+  // add our constructor functions
+  ObjectTemplateHelper::InstallFunctions( isolate,
+                                          objTemplate,
+                                          ConstructorFunctionTable,
+                                          PropertyFunctionTableCount,
+                                          ObjectTemplateHelper::CONSTRUCTOR_FUNCTIONS);
+
+  return handleScope.Escape( objTemplate );
+}
+
+void DaliWrapper::Require(const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  DaliWrapper& wrapper( DaliWrapper::Get() );
+  wrapper.mModuleLoader.Require( args, wrapper.mGlobalObjectTemplate );
+}
+
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/dali-wrapper.h b/plugins/dali-script-v8/src/dali-wrapper.h
new file mode 100644
index 0000000..27d4fd3
--- /dev/null
+++ b/plugins/dali-script-v8/src/dali-wrapper.h
@@ -0,0 +1,161 @@
+#ifndef __DALI_V8PLUGIN_DALI_WRAP_H__
+#define __DALI_V8PLUGIN_DALI_WRAP_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * Sets up JavaScript context and environment and allows execution of JavaScript in the context
+ *
+ *
+ * Exceptions
+ * ----------
+ *
+ * Execptions can be raised by calling DALI_SCRIPT_EXCEPTION()
+ *
+ * Expections break JavaScript execution with a printout but do not cause a c++ exception.
+ * So always return from the calling function before attempting to run any further V8 code.
+ *
+ * Coding Style
+ * ------------
+ *
+ *  Uses Tizen Web API coding style, which appears to be the same as this:
+ *
+ *  https://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml
+ *
+ * "In general, use
+ *
+ * functionNamesLikeThis,
+ * variableNamesLikeThis,
+ * ClassNamesLikeThis,
+ * ConstructorsLikeThis,
+ * EnumNamesLikeThis,
+ * methodNamesLikeThis,
+ * CONSTANT_VALUES_LIKE_THIS,
+ * foo.namespaceNamesLikeThis.bar,
+ * filenameslikethis.js. "
+ */
+class DALI_INTERNAL DaliWrapper
+{
+public:
+
+  /**
+   * Constructor
+   */
+  DaliWrapper();
+
+  /**
+   * non virtual destructor, not intended as a base class
+   */
+  ~DaliWrapper();
+
+  /**
+   * Gets the DaliWrapper singleton.
+   *
+   * @return the wrapper
+   */
+  static DaliWrapper& Get();
+
+  /**
+   * Set V8 engine configuration flags
+   *
+   * @param[in] flags Configruation flags (See v8 documentation)
+   */
+  void SetFlagsFromString(const std::string& flags);
+
+  /**
+   * Delete the current V8 context
+   */
+  void Shutdown();
+
+  /**
+   * Excute the buffer in the v8 context
+   *
+   * @param[in] sourceCode The buffer containing javascript to execute
+   * @param[in] sourceFileName Filename associated with the buffer (for error tracing)
+   */
+  void ExecuteBuffer(const std::string &sourceCode, const std::string &sourceFileName);
+
+
+  /**
+   * Excute the buffer in the v8 context
+   *
+   * @param[in] sourceFileName Filename associated with the buffer (for error tracing)
+   */
+  void ExecuteFile( const std::string& sourceFileName);
+
+
+  /**
+   * Get DALi's own garbage collector
+   * @return garbage collector interface
+   */
+  GarbageCollectorInterface& GetDaliGarbageCollector();
+
+private:
+
+  /**
+   * Create V8 context
+   */
+  void CreateContext();
+
+  /**
+   * Initialize DaliWrapper
+   */
+  void Initialize();
+
+  /**
+   * Create Dali ObjectTemplate
+   * @return the Dali ObjectTemplate
+   */
+  static v8::Handle NewDaliObjectTemplate( v8::Isolate* isolate );
+
+  /**
+   * Called when require keyword is found in a script
+   */
+  static void Require(const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  static bool mInstanceCreated;                                 ///< whether an instance has been created
+  static DaliWrapper* mWrapper;                                 ///< static pointer to the wrapper
+
+  GarbageCollector mGarbageCollector;                           ///< DALi garbage collector
+  ModuleLoader mModuleLoader;                                   ///< Module loader
+  v8::Persistent mContext;                         ///< A sandboxed execution context with its own set of built-in objects and functions.
+  v8::Persistent mGlobalObjectTemplate;     ///< Global object template for storing things like dali global object
+  v8::Isolate* mIsolate;                                        ///< represents an isolated instance of the V8 engine.
+
+};
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/events/event-object-generator.cpp b/plugins/dali-script-v8/src/events/event-object-generator.cpp
new file mode 100644
index 0000000..f41f5ac
--- /dev/null
+++ b/plugins/dali-script-v8/src/events/event-object-generator.cpp
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "event-object-generator.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+
+struct PointState
+{
+  TouchPoint::State state;
+  const char* name;
+};
+
+const PointState PointStateLookup[]=
+{
+    { TouchPoint::Down,         "down"        },       /**< Screen touched */
+    { TouchPoint::Up,           "up"          },       /**< Touch stopped */
+    { TouchPoint::Motion,       "motion"      },       /**< Touch stopped */
+    { TouchPoint::Leave,        "leave"       },       /**< Touch stopped */
+    { TouchPoint::Stationary,   "stationary"  },       /**< Touch stopped */
+    { TouchPoint::Interrupted,  "interrupt"   },       /**< Touch stopped */
+    { TouchPoint::Started,      "started"     },       /**< Touch or hover started */
+    { TouchPoint::Finished,     "finished"    },       /**< Touch or hover finished */
+};
+
+const unsigned int PointStateLookupCount = sizeof(PointStateLookup)/sizeof(PointStateLookup[0]);
+
+struct GestureState
+{
+  Gesture::State state;
+  const char* name;
+};
+
+const GestureState GestureStateLookup[]=
+{
+    { Gesture::Clear,      "clear"        },       /**< No state associated */
+    { Gesture::Started,    "started"      },       /**< Gesture started */
+    { Gesture::Continuing, "continuing"   },       /**< Gesture continuing */
+    { Gesture::Finished,   "finished"     },       /**< Gesture finished */
+    { Gesture::Cancelled,  "cancelled"    },       /**< Gesture cancelled */
+    { Gesture::Possible,   "possible"     },       /**< Gesture is possible */
+};
+
+const unsigned int GestureStateLookupCount = sizeof(GestureStateLookup)/sizeof(GestureStateLookup[0]);
+
+const char* GetTouchPointStateName( TouchPoint::State state )
+{
+  // could use the enum as index, but dali-core may change, so for now just do a lookup
+  for( unsigned int i = 0; i < PointStateLookupCount; i++ )
+  {
+    if( PointStateLookup[i].state == state )
+    {
+      return PointStateLookup[i].name;
+    }
+  }
+  return "error point state not found";
+}
+
+const char* GetGestureStateName( Gesture::State state )
+{
+  // could use the enum as index, but dali-core may change, so for now just do a lookup
+  for( unsigned int i = 0; i < GestureStateLookupCount; i++ )
+  {
+    if( GestureStateLookup[i].state == state )
+    {
+      return GestureStateLookup[i].name;
+    }
+  }
+  return "error gesture state not found";
+}
+
+// create a point object, x,y
+v8::Local CreateTouchPoint( v8::Isolate* isolate, const TouchPoint& touchPoint )
+{
+  /*
+   * touch point object
+   *
+   *   { "deviceId",  int }  Each touch point has a unique device ID
+   *   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
+   *   { "hitActor", actor } actor that was hit ( wrapped dali object)
+   *   { "local",  {x,y} } co-ordinates of top left of hit actor
+   *   { "screen", {x,y} } co-ordinates of top left of hit actor
+   */
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local pointObject = v8::Object::New( isolate );
+
+  // set device id
+  pointObject->Set( v8::String::NewFromUtf8( isolate, "deviceId"), v8::Integer::New( isolate, touchPoint.deviceId ));
+
+  // set state
+  pointObject->Set( v8::String::NewFromUtf8( isolate, "state"), v8::String::NewFromUtf8( isolate, GetTouchPointStateName(touchPoint.state)));
+
+  // set the hit actor
+  pointObject->Set( v8::String::NewFromUtf8( isolate, "hitActor"), ActorWrapper::WrapActor(isolate, touchPoint.hitActor ));
+
+  // Think about changing these Vector 2 from wrapped objects to JavaScript objects...
+
+  // Set the local co-ordinates
+  v8::Local localPointObject = v8::Object::New( isolate );
+  localPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, touchPoint.local.x) );
+  localPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, touchPoint.local.y) );
+  pointObject->Set( v8::String::NewFromUtf8( isolate, "local"),  localPointObject);
+
+
+  // set the screen co-ordinates
+  v8::Local screenPointObject = v8::Object::New( isolate );
+  screenPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, touchPoint.screen.x) );
+  screenPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, touchPoint.screen.y) );
+  pointObject->Set( v8::String::NewFromUtf8( isolate, "screen"), screenPointObject );
+
+
+  return handleScope.Escape( pointObject );
+}
+
+} // un-named namespace
+
+
+v8::Handle EventObjectGenerator::CreateTouchEvent( v8::Isolate* isolate, const TouchEvent& touchEvent)
+{
+  // we are creating a touch event object that looks like this
+  //
+  //  event.pointCount = points touched
+  //  event.time       = The time (in ms) that the touch event occurred.
+  //  event.point[]    = array of TouchPoints
+  //
+  // A TouchPoint =
+  //   { "deviceId",  int }  Each touch point has a unique device ID
+  //   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
+  //   { "sourceActor", actor }  the actor that is emitting the callback (the actor that is hit maybe a child of it)
+  //   { "hitActor", actor } actor that was hit
+  //   { "local",  {x,y} } co-ordinates of top left of hit actor
+  //   { "screen", {x,y} } co-ordinates of top left of hit actor
+  //
+
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local touchObject = v8::Object::New( isolate );
+
+  // Set the pointCount
+  touchObject->Set( v8::String::NewFromUtf8( isolate, "pointCount" ), v8::Integer::New( isolate, touchEvent.GetPointCount() ) );
+
+  // Set the time
+  touchObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, touchEvent.time ) );
+
+  // Set the emitting actor
+  // touchObject->Set( v8::String::NewFromUtf8( isolate, "sourceActor" ), ActorWrapper::WrapActor(isolate, emittingActor));
+
+  // Create the array of touch points
+  v8::Local < v8::Array > pointArrayObject = v8::Array::New( isolate, touchEvent.GetPointCount() );
+  for( unsigned int i = 0 ; i < touchEvent.GetPointCount() ; ++i )
+  {
+    v8::Local < v8::Object > pointObject = CreateTouchPoint( isolate, touchEvent.points[i] );
+    pointArrayObject->Set( v8::Number::New( isolate, i ), pointObject  );
+  }
+
+  // set the array
+  touchObject->Set( v8::String::NewFromUtf8( isolate, "points" ), pointArrayObject );
+
+  return handleScope.Escape( touchObject );
+}
+
+v8::Handle EventObjectGenerator::CreateHoverEvent( v8::Isolate* isolate, const HoverEvent& hoverEvent)
+{
+  // we are creating a hover event object that looks like this
+  //
+  //  event.pointCount = points hovered
+  //  event.time       = The time (in ms) that the hover event occurred.
+  //  event.point[]    = array of TouchPoints
+  //
+  // A TouchPoint =
+  //   { "deviceId",  int }  Each touch point has a unique device ID
+  //   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
+  //   { "sourceActor", actor }  the actor that is emitting the callback (the actor that is hit maybe a child of it)
+  //   { "hitActor", actor } actor that was hit
+  //   { "local",  {x,y} } co-ordinates of top left of hit actor
+  //   { "screen", {x,y} } co-ordinates of top left of hit actor
+  //
+
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local hoverObject = v8::Object::New( isolate );
+
+  // Set the pointCount
+  hoverObject->Set( v8::String::NewFromUtf8( isolate, "pointCount" ), v8::Integer::New( isolate, hoverEvent.GetPointCount() ) );
+
+  // Set the time
+  hoverObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, hoverEvent.time ) );
+
+  // Set the emitting actor
+  // hoverObject->Set( v8::String::NewFromUtf8( isolate, "sourceActor" ), ActorWrapper::WrapActor(isolate, emittingActor));
+
+  // Create the array of touch points
+  v8::Local < v8::Array > pointArrayObject = v8::Array::New( isolate, hoverEvent.GetPointCount() );
+  for( unsigned int i = 0 ; i < hoverEvent.GetPointCount() ; ++i )
+  {
+    v8::Local < v8::Object > pointObject = CreateTouchPoint( isolate, hoverEvent.points[i] );
+    pointArrayObject->Set( v8::Number::New( isolate, i ), pointObject  );
+  }
+
+  // set the array
+  hoverObject->Set( v8::String::NewFromUtf8( isolate, "points" ), pointArrayObject );
+
+  return handleScope.Escape( hoverObject );
+}
+
+v8::Handle EventObjectGenerator::CreateMouseWheelEvent( v8::Isolate* isolate, const MouseWheelEvent& wheelEvent)
+{
+  //  we are creating a mouse wheel event object that looks like this
+  //
+  //  event.direction = "vertical" or "horizontal" direction the wheel is being rolled
+  //  event.shiftPressed       = boolean, shift key is held
+  //  event.ctrlPressed        = boolean, ctrl key is held
+  //  event.altPressed     = boolean, alt key is held
+  //  event.keyModifiers = bitmask of keys pressed
+  //  event.point {x,y}    = The co-ordinates of the mouse cursor relative to the top-left of the screen when the wheel is being rolled.
+  //  event.rolled          = offset of mouse wheel rolling, positive = rolling down, negative = rolling up
+  //  event.timestamp    = The time (in ms) that the touch event occurred
+
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local wheelObject = v8::Object::New( isolate );
+
+  // Set the direction
+  std::string direction = wheelEvent.direction ? "vertical" : "horizontal";
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "direction" ), v8::String::NewFromUtf8( isolate, direction.c_str() ) );
+
+  // set shift / ctrl/ alt keys
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "shiftPressed" ), v8::Boolean::New( isolate, wheelEvent.IsShiftModifier()) );
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "ctrlPressed" ),  v8::Boolean::New( isolate, wheelEvent.IsCtrlModifier()) );
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "altPressed" ),   v8::Boolean::New( isolate, wheelEvent.IsAltModifier()) );
+
+  // set keyModifiers
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "keyModifiers" ),  v8::Integer::New( isolate, wheelEvent.modifiers) );
+
+  // set Point
+  v8::Local wheelPointObject = v8::Object::New( isolate );
+  wheelPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, wheelEvent.point.x ) );
+  wheelPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, wheelEvent.point.y ) );
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "point"), wheelPointObject );
+
+  // set rolledAmout
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "rolled" ),  v8::Integer::New( isolate, wheelEvent.z) );
+
+  // set timestamp
+  wheelObject->Set( v8::String::NewFromUtf8( isolate, "timestamp" ),  v8::Integer::New( isolate, wheelEvent.timeStamp) );
+
+  return handleScope.Escape( wheelObject );
+
+}
+
+v8::Handle EventObjectGenerator::CreateKeyEvent( v8::Isolate* isolate, const KeyEvent& keyEvent)
+{
+  // keyCode
+  // keyModifier
+  // event.keyCode       = key code
+  // event.key           = key presssed
+  // event.keyDescription = key description, e.g. BackSpace
+  // event.state = "down" or "up" key state
+  // event.shiftPressed  = boolean, shift key is held
+  // event.ctrlPressed   = boolean, ctrl key is held
+  // event.altPressed    = boolean, alt key is held
+  // event.keyModifiers  = key modifiers
+  // event.timestamp     = Time stamp
+
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local keyObject = v8::Object::New( isolate );
+
+  // Set the direction
+  std::string state ("up");
+  if ( keyEvent.state == KeyEvent::Down)
+  {
+    state = "down";
+  }
+
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "state" ), v8::String::NewFromUtf8( isolate, state.c_str() ) );
+
+  // set keyCode
+   keyObject->Set( v8::String::NewFromUtf8( isolate, "keyCode" ),  v8::Integer::New( isolate, keyEvent.keyCode) );
+
+  // set keyModifiers
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "keyModifier" ),  v8::Integer::New( isolate, keyEvent.keyModifier) );
+
+  // set Key pressed name
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "keyDescription" ),  v8::String::NewFromUtf8( isolate, keyEvent.keyPressedName.c_str() )  );
+
+  // set Key pressed
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "key" ),  v8::String::NewFromUtf8( isolate, keyEvent.keyPressed.c_str() )  );
+
+  // set time stamp
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "timestamp" ),  v8::Integer::New( isolate, keyEvent.time) );
+
+  // set shift / ctrl/ alt keys
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "shiftPressed" ), v8::Boolean::New( isolate, keyEvent.IsShiftModifier()) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "ctrlPressed" ),  v8::Boolean::New( isolate, keyEvent.IsCtrlModifier()) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "altPressed" ),   v8::Boolean::New( isolate, keyEvent.IsAltModifier()) );
+
+  return handleScope.Escape( keyObject );
+
+}
+
+v8::Handle EventObjectGenerator::CreatePanGesture( v8::Isolate* isolate, const PanGesture& panGesture)
+{
+  // gesture.numberOfTouches     = total number of fingers touching the screen
+  // gesture.state               = pan state {Clear, Started, Continuing, Finished, Cancelled, Possible}
+  // gesture.time                = Time stamp
+  // gesture.velocity            = pan velocity in actor coordinates
+  // gesture.displacement        = pan displacement in actor coordinates
+  // gesture.position            = pan position in actor coordinates
+  // gesture.screenVelocity      = pan velocity in screen coordinates
+  // gesture.screenDisplacement  = pan displacement in screen coordinates
+  // gesture.screenPosition      = pan position in screen coordinates
+
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local panObject = v8::Object::New( isolate );
+
+  // Set the numberOfTouches
+  panObject->Set( v8::String::NewFromUtf8( isolate, "numberOfTouches" ), v8::Integer::New( isolate, panGesture.numberOfTouches ) );
+
+  // Set the state
+  panObject->Set( v8::String::NewFromUtf8( isolate, "state"), v8::String::NewFromUtf8( isolate, GetGestureStateName(panGesture.state)));
+
+  // Set the time
+  panObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, panGesture.time ) );
+
+  // Set the local velocity
+  v8::Local velocityObject = v8::Object::New( isolate );
+  velocityObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.velocity.x) );
+  velocityObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.velocity.y) );
+  panObject->Set( v8::String::NewFromUtf8( isolate, "velocity"),  velocityObject);
+
+  // Set the local displacement
+  v8::Local displacementObject = v8::Object::New( isolate );
+  displacementObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.displacement.x) );
+  displacementObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.displacement.y) );
+  panObject->Set( v8::String::NewFromUtf8( isolate, "displacement"),  displacementObject);
+
+  // Set the local position
+  v8::Local positionObject = v8::Object::New( isolate );
+  positionObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.position.x) );
+  positionObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.position.y) );
+  panObject->Set( v8::String::NewFromUtf8( isolate, "position"),  positionObject);
+
+  // Set the screen velocity
+  v8::Local screenVelocityObject = v8::Object::New( isolate );
+  screenVelocityObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenVelocity.x) );
+  screenVelocityObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenVelocity.y) );
+  panObject->Set( v8::String::NewFromUtf8( isolate, "screenVelocity"),  screenVelocityObject);
+
+  // Set the screen displacement
+  v8::Local screenDisplacementObject = v8::Object::New( isolate );
+  screenDisplacementObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenDisplacement.x) );
+  screenDisplacementObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenDisplacement.y) );
+  panObject->Set( v8::String::NewFromUtf8( isolate, "screenDisplacement"),  screenDisplacementObject);
+
+  // Set the screen position
+  v8::Local screenPositionObject = v8::Object::New( isolate );
+  screenPositionObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenPosition.x) );
+  screenPositionObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenPosition.y) );
+  panObject->Set( v8::String::NewFromUtf8( isolate, "screenPosition"),  screenPositionObject);
+
+  return handleScope.Escape( panObject );
+
+}
+
+
+
+} // V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/events/event-object-generator.h b/plugins/dali-script-v8/src/events/event-object-generator.h
new file mode 100644
index 0000000..8083255
--- /dev/null
+++ b/plugins/dali-script-v8/src/events/event-object-generator.h
@@ -0,0 +1,59 @@
+#ifndef __DALI_V8PLUGIN_EVENT_OBJECT_GENERATOR_H__
+#define __DALI_V8PLUGIN_EVENT_OBJECT_GENERATOR_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * Used to convert Dali event objects into pure JavaScript objects.
+ * The objects created are not wrappers around a Dali object,
+ * however TouchPoint.Actor is a wrapped actor
+ */
+namespace EventObjectGenerator
+{
+
+  v8::Handle CreateTouchEvent( v8::Isolate* isolate, const TouchEvent& touchEvent);
+  v8::Handle CreateHoverEvent( v8::Isolate* isolate, const HoverEvent& hoverEvent);
+  v8::Handle CreateMouseWheelEvent( v8::Isolate* isolate, const MouseWheelEvent& wheelEvent);
+  v8::Handle CreateKeyEvent( v8::Isolate* isolate, const KeyEvent& keyEvent);
+  v8::Handle CreatePanGesture( v8::Isolate* isolate, const PanGesture& panGesture);
+
+
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/events/pan-gesture-detector-api.cpp b/plugins/dali-script-v8/src/events/pan-gesture-detector-api.cpp
new file mode 100644
index 0000000..e1216b4
--- /dev/null
+++ b/plugins/dali-script-v8/src/events/pan-gesture-detector-api.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "pan-gesture-detector-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // unnamed namespace
+{
+
+PanGestureDetector GetPanGestureDetector( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField( 0 ) );
+  void* ptr = field->Value();
+
+  PanGestureDetectorWrapper* wrapper = static_cast( ptr );
+  return wrapper->GetPanGestureDetector();
+}
+
+} // unnamed namespace
+
+/**
+ * Constructor
+ *
+ * @constructor
+ * @for PanGestureDetector
+ * @method PanGestureDetector
+ */
+PanGestureDetector PanGestureDetectorApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  return PanGestureDetector::New();
+}
+
+/**
+ * Attaches an actor to the pan gesture.
+ *
+ * The pan-detected signal will be dispatched when the pan gesture occurs on
+ * the attached actor. You can attach several actors to a pan gesture detector.
+ * @method attach
+ * @for PanGestureDetector
+ * @param {Actor} actor The actor to attach to the pan gesture detector
+ * @example
+ *        panGestureDetector.attach(actor);
+ */
+void PanGestureDetectorApi::Attach( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found( false );
+  //Get actor
+  Dali::Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    PanGestureDetector panGestureDetector = GetPanGestureDetector( isolate, args );
+    panGestureDetector.Attach( actor );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+  }
+}
+
+
+/**
+ * Detaches the attached actor from the pan gesture detector.
+ *
+ * The specified actor should have been attached to the pan gesture detector
+ * @method detach
+ * @for PanGestureDetector
+ * @param {Actor} actor The actor to detach from the pan gesture detector
+ * @example
+ *        panGestureDetector.detach(actor);
+ */
+void PanGestureDetectorApi::Detach( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found( false );
+  //Get actor
+  Dali::Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    PanGestureDetector panGestureDetector = GetPanGestureDetector( isolate, args );
+    panGestureDetector.Detach( actor );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" );
+  }
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/events/pan-gesture-detector-api.h b/plugins/dali-script-v8/src/events/pan-gesture-detector-api.h
new file mode 100644
index 0000000..8a33566
--- /dev/null
+++ b/plugins/dali-script-v8/src/events/pan-gesture-detector-api.h
@@ -0,0 +1,50 @@
+#ifndef __DALI_V8PLUGIN_PAN_GESTURE_DETECTOR_API_H__
+#define __DALI_V8PLUGIN_PAN_GESTURE_DETECTOR_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace PanGestureDetectorApi
+{
+  /**
+   * Constructor
+   */
+  PanGestureDetector New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * PanGestureDetector API see gesture-detector.h for a description
+   */
+  void Attach( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Detach( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace PanGestureDetectorApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_PAN_GESTURE_DETECTOR_API_H__
diff --git a/plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.cpp b/plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.cpp
new file mode 100644
index 0000000..e6ac829
--- /dev/null
+++ b/plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "pan-gesture-detector-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+
+const ApiFunction PanGestureDetectorFunctions[]=
+{
+ { "Attach",  PanGestureDetectorApi::Attach },
+ { "Detach",  PanGestureDetectorApi::Detach }
+};
+
+const unsigned int PanGestureDetectorFunctionTableCount = sizeof(PanGestureDetectorFunctions)/sizeof(PanGestureDetectorFunctions[0]);
+} //un-named space
+
+
+PanGestureDetectorWrapper::PanGestureDetectorWrapper( PanGestureDetector panGestureDetector, GarbageCollectorInterface& gc )
+:HandleWrapper( BaseWrappedObject::PAN_GESTURE_DETECTOR, panGestureDetector, gc ),
+ mPanGestureDetector( panGestureDetector )
+{
+}
+
+v8::Handle PanGestureDetectorWrapper::MakePanGestureDetectorTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, PanGestureDetectorFunctions, PanGestureDetectorFunctionTableCount );
+
+  // property handle intercepts property getters and setters and signals
+  HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
+
+  return handleScope.Escape( objTemplate );
+}
+
+v8::Handle PanGestureDetectorWrapper::WrapPanGestureDetector( v8::Isolate* isolate, PanGestureDetector panGestureDetector )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = MakePanGestureDetectorTemplate( isolate );
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the Dali object
+  PanGestureDetectorWrapper* pointer = new PanGestureDetectorWrapper( panGestureDetector, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  // This also stores Dali object, in an internal field inside the JavaScript object.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+PanGestureDetector PanGestureDetectorWrapper::GetPanGestureDetector()
+{
+  return mPanGestureDetector;
+}
+
+/**
+ * Create an initialized PanGestureDetector handle.
+ * @constructor
+ * @for PanGestureDetector
+ * @method PanGestureDetector
+ */
+void PanGestureDetectorWrapper::NewPanGestureDetector( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  if( !args.IsConstructCall() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "constructor called without 'new" );
+    return;
+  }
+
+  // Create a new path
+  PanGestureDetector panGestureDetector = PanGestureDetector::New();
+  v8::Local localObject = WrapPanGestureDetector( isolate, panGestureDetector );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.h b/plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.h
new file mode 100644
index 0000000..59d824d
--- /dev/null
+++ b/plugins/dali-script-v8/src/events/pan-gesture-detector-wrapper.h
@@ -0,0 +1,82 @@
+#ifndef __DALI_V8PLUGIN_PAN_GESTURE_DETECTOR_WRAPPER_H__
+#define __DALI_V8PLUGIN_PAN_GESTURE_DETECTOR_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * Wraps a PanGestureDetector.
+ */
+class PanGestureDetectorWrapper : public HandleWrapper
+{
+
+public:
+
+  /**
+   * Constructor
+   */
+  PanGestureDetectorWrapper( PanGestureDetector panGestureDetector, GarbageCollectorInterface& gc );
+
+  /**
+   * Virtual destructor
+   */
+  virtual ~PanGestureDetectorWrapper(){};
+
+  /**
+   * Creates a new PanGestureDetector wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewPanGestureDetector( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps a PanGestureDetector inside a Javascript object
+   */
+  static v8::Handle WrapPanGestureDetector(v8::Isolate* isolate, PanGestureDetector panGestureDetector );
+
+  /*
+   * Get the wrapped PanGestureDetector
+   */
+  PanGestureDetector GetPanGestureDetector();
+
+private:
+
+  /**
+   * Create a v8 object template for the PanGestureDetector
+   */
+  static v8::Handle MakePanGestureDetectorTemplate( v8::Isolate* isolate );
+
+  PanGestureDetector mPanGestureDetector;
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/garbage-collector/garbage-collector.cpp b/plugins/dali-script-v8/src/garbage-collector/garbage-collector.cpp
new file mode 100644
index 0000000..ffc118d
--- /dev/null
+++ b/plugins/dali-script-v8/src/garbage-collector/garbage-collector.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "garbage-collector.h"
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+GarbageCollector::GarbageCollector()
+{
+
+}
+GarbageCollector::~GarbageCollector()
+{
+  GarbageCollect();
+}
+
+void GarbageCollector::Register( BaseWrappedObject* object )
+{
+  mObjectMap.insert( object );
+};
+
+
+void GarbageCollector::UnRegister( BaseWrappedObject* object )
+{
+  mObjectMap.erase( object );
+}
+
+
+void GarbageCollector::GarbageCollect()
+{
+  for( ObjectMap::iterator iter = mObjectMap.begin(); iter != mObjectMap.end();  )
+  {
+    BaseWrappedObject* object = *iter;
+    iter++; // iterator will be invalidated if we delete the object first.
+    delete object; // object will call GarbageCollector.UnRegister
+  }
+
+}
+
+} // V8Plugin
+
+} // Dali
diff --git a/plugins/dali-script-v8/src/garbage-collector/garbage-collector.h b/plugins/dali-script-v8/src/garbage-collector/garbage-collector.h
new file mode 100644
index 0000000..c97ee40
--- /dev/null
+++ b/plugins/dali-script-v8/src/garbage-collector/garbage-collector.h
@@ -0,0 +1,82 @@
+#ifndef __DALI_V8PLUGIN_GARBAGE_COLLECTOR_H__
+#define __DALI_V8PLUGIN_GARBAGE_COLLECTOR_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * @brief concrete interface of Dali's garbage collector interface.
+ */
+class GarbageCollector : public GarbageCollectorInterface
+{
+
+public:
+
+  /**
+   * Constructor
+   */
+  GarbageCollector();
+
+  /**
+   * Destructor
+   */
+  ~GarbageCollector();
+
+  /**
+   * @copydoc GarbageCollectorInterface::Register()
+   */
+  virtual void Register( BaseWrappedObject* object );
+
+  /**
+   * @copydoc GarbageCollectorInterface::UnRegister()
+   */
+  virtual void UnRegister( BaseWrappedObject* object );
+
+  /**
+   * @copydoc GarbageCollectorInterface::GarbageCollect()
+   */
+  virtual void GarbageCollect();
+
+
+private:
+
+  /**
+   * Map between dali wrapped object (void *)
+   */
+  typedef std::set< BaseWrappedObject* > ObjectMap;
+  ObjectMap mObjectMap;   ///< lookup
+
+};
+
+} // V8Plugin
+
+} // Dali
+
+#endif // header __DALI_V8PLUGIN_GARBAGE_COLLECTOR_H__
diff --git a/plugins/dali-script-v8/src/image/buffer-image-api.cpp b/plugins/dali-script-v8/src/image/buffer-image-api.cpp
new file mode 100644
index 0000000..ac07889
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/buffer-image-api.cpp
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "buffer-image-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * ## BufferImage
+ * Bitmap represents an image resource that can be added to ImageActors.
+ * Its pixel buffer data is provided by the application developer.
+ *
+ * If the pixel format of the pixel buffer contains an alpha channel,
+ * then the image is considered to be have transparent pixels without
+ * regard for the actual content of the channel, and will be blended.
+ * @class BufferImage
+ * @extends Image
+ */
+BufferImage BufferImageApi::GetBufferImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  ImageWrapper* wrapper = static_cast< ImageWrapper *>(ptr);
+  return BufferImage::DownCast( wrapper->GetImage() );
+}
+
+/**
+ * Create a new buffer image object ** ( work in progress, will currently only work with no parameters ) **
+ * If no parameters are passed in, a single pixel white buffer image is created.
+ *
+ *
+ * For better performance and portability use power of two dimensions.
+ * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE.
+ *
+ * @note in case releasePolicy is "Unused", application has to call
+ * BufferImage::Update() whenever image is re-added to the stage
+ *
+ * Example of creating a Uint32Array buffer
+ * ```
+ * "var ab = new ArrayBuffer(256 x 256 );"
+ *  var pixelBuffer = new Uint32Array(ab );
+ * ```
+ * @constructor
+ * @method BufferImage
+ * @for BufferImage
+ * @param {Object} options
+ * @param {Uint32Array} options.pixelBuffer Array of RGBA pixel data
+ * @param {Integer} options.width image width
+ * @param {Integer} options.height image height
+ * @param {Integer} options.pixelFormat pixel format ( see dali constants, e.g. dali.PIXEL_FORMAT_RGB8888)
+ * @param {Integer} [options.stride the] internal stride of the pixelbuffer in pixels (normally the width)
+ * @param {Integer} [options.releasePolicy] optionally release memory when image is not visible on screen.
+ * @return {Object} Image
+ */
+Image BufferImageApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  v8::Local options( args[0] );
+  if( !options->IsObject() )
+  {
+    return BufferImage::WHITE();
+  }
+
+  v8::Local obj = options->ToObject();
+
+  v8::Local widthValue = obj->Get( v8::String::NewFromUtf8( isolate, "width" ) );
+  v8::Local heightValue= obj->Get( v8::String::NewFromUtf8( isolate, "height" ) );
+
+  unsigned int width = 0;
+  unsigned int height = 0;
+
+  if( widthValue->IsUint32() && heightValue->IsUint32() )
+  {
+    width = widthValue->ToUint32()->Value();
+    height = heightValue->ToUint32()->Value();
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing valid width and height params");
+    return BufferImage();
+  }
+
+  Pixel::Format  pixelFormat = Pixel::RGB8888;
+  v8::Local pixelFormatValue = obj->Get( v8::String::NewFromUtf8( isolate, "pixelFormat" ) );
+  if( pixelFormatValue->IsUint32() )
+  {
+     pixelFormat = static_cast( pixelFormatValue->ToUint32()->Value() );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Pixel format not specified");
+    return BufferImage();
+  }
+
+  v8::Local pixelArray= obj->Get( v8::String::NewFromUtf8( isolate, "pixelBuffer" ) );
+  if( pixelArray->IsUint32Array() )
+  {
+    //v8::Local v8Array = v8::Local::Cast( pixelArray );
+   // uint32_t elementCount = v8Array->Length();
+    DALI_SCRIPT_EXCEPTION( isolate, "pixel buffer currently not supported \n");
+    return BufferImage::WHITE();
+   }
+
+
+  unsigned int stride = width;
+  v8::Local strideValue = obj->Get( v8::String::NewFromUtf8( isolate, "stride" ) );
+  if( strideValue->IsUint32() )
+  {
+    stride = strideValue->ToUint32()->Value();
+  }
+
+  Image::ReleasePolicy releasePolicy =  Dali::Image::NEVER;
+  v8::Local releasePolicyValue = obj->Get( v8::String::NewFromUtf8( isolate, "releasePolicy" ) );
+  if( releasePolicyValue->IsUint32() )
+  {
+    releasePolicy = static_cast( releasePolicyValue->ToUint32()->Value() );
+  }
+
+  DALI_SCRIPT_EXCEPTION( isolate, "pixel buffer currently not supported \n");
+
+  return BufferImage::New( NULL, width, height, pixelFormat, stride, releasePolicy);
+
+}
+/**
+ * @brief Returns the pixel buffer of the Image **( currently not supported ) **
+ * @method getBuffer
+ * @for BufferImage
+ * @return {Object}
+ */
+void BufferImageApi::GetBuffer( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  BufferImage image = GetBufferImage( isolate, args );
+
+  //@todo figure out what the best thing to do here is...
+  // we could copy the data into a javascript array
+}
+
+/**
+ * @brief Returns buffer size in bytes.
+ * @method getBufferSize
+ * @for BufferImage
+ * @return {Object} buffer
+ */
+void BufferImageApi::GetBufferSize( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  BufferImage image = GetBufferImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetBufferSize() ) );
+
+}
+/**
+ * @brief Returns buffer stride in bytes.
+ * @method getBufferStride
+ * @for BufferImage
+ * @return {Object}
+ */
+void BufferImageApi::GetBufferStride( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  BufferImage image = GetBufferImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetBufferStride() ) );
+
+}
+/**
+ * @brief Returns pixel format
+ * @method getPixelFormat
+ * @for BufferImage
+ * @return {Integer} pixel format
+ */
+void BufferImageApi::GetPixelFormat( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  BufferImage image = GetBufferImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetPixelFormat() ) );
+
+}
+
+/**
+ * @brief  Inform Dali that the contents of the buffer have changed
+ * @todo support update an area
+ * @method update
+ * @for BufferImage
+ */
+void BufferImageApi::Update( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  BufferImage image = GetBufferImage( isolate, args );
+
+  image.Update();
+
+}
+/**
+ * @brief  returns whether BufferImage uses external data source or not.
+ * @method isDataExternal
+ * @for BufferImage
+ * @return {Boolean} true if data is external
+ */
+void BufferImageApi::IsDataExternal( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  BufferImage image = GetBufferImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, image.IsDataExternal() ) );
+
+}
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/buffer-image-api.h b/plugins/dali-script-v8/src/image/buffer-image-api.h
new file mode 100644
index 0000000..b46f2e3
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/buffer-image-api.h
@@ -0,0 +1,62 @@
+#ifndef __DALI_V8PLUGIN_RESOURCE_BUFFER_IMAGE_API_H__
+#define __DALI_V8PLUGIN_RESOURCE_BUFFER_IMAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace BufferImageApi
+{
+  /**
+   * Helper to get buffer-image from args.This()
+   */
+  BufferImage GetBufferImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Constructor
+   */
+  Image New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Buffer Image API see buffer-image.h for a description
+   */
+  void GetBuffer( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBufferSize( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBufferStride( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetPixelFormat( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Update( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsDataExternal( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace BufferImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_RESOURCE_BUFFER_IMAGE_API_H__
diff --git a/plugins/dali-script-v8/src/image/frame-buffer-image-api.cpp b/plugins/dali-script-v8/src/image/frame-buffer-image-api.cpp
new file mode 100644
index 0000000..eb7f546
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/frame-buffer-image-api.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "frame-buffer-image-api.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace FrameBufferImageApi
+{
+
+/**
+ * FrameBufferImage represents a GLES Frame Buffer Object and contains the result
+ * of an 'off screen' render pass of a RenderTask.
+ * The FrameBufferImage can then be used with an ImageActor (with optional shader
+ * effects) and rendered to the screen.
+ * @class FrameBufferImage
+ * @extends Image
+ */
+
+/**
+ * @constructor
+ * @method FrameBufferImage
+ * @for FrameBufferImage
+ * @param {Object} options
+ * @param {Uint32Array} options.pixelBuffer Array of RGBA pixel data
+ * @param {Integer} options.width image width
+ * @param {Integer} options.height image height
+ * @param {Object } [options.nativeImage] ** currently not supported **
+ * @param {Integer} [options.pixelFormat] pixel format ( see dali constants, e.g. dali.PIXEL_FORMAT_RGB8888)
+ * @param {Integer} [options.releasePolicy] optionally release memory when image is not visible on screen.
+ * @return {Object} Image
+ */
+Image New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local options( args[0] );
+  if( !options->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing param");
+    return FrameBufferImage();
+  }
+
+  v8::Local obj = options->ToObject();
+
+  v8::Local widthValue = obj->Get( v8::String::NewFromUtf8( isolate, "width" ) );
+  v8::Local heightValue= obj->Get( v8::String::NewFromUtf8( isolate, "height" ) );
+
+  unsigned int width = 0;
+  unsigned int height = 0;
+
+  if( widthValue->IsUint32() && heightValue->IsUint32() )
+  {
+    width = widthValue->ToUint32()->Value();
+    height = heightValue->ToUint32()->Value();
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing valid width and height params");
+    return FrameBufferImage();
+  }
+
+  Pixel::Format  pixelFormat = Pixel::RGB8888;
+  v8::Local pixelFormatValue = obj->Get( v8::String::NewFromUtf8( isolate, "pixelFormat" ) );
+  if( pixelFormatValue->IsUint32() )
+  {
+     pixelFormat = static_cast( pixelFormatValue->ToUint32()->Value() );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Pixel format not specified");
+    return FrameBufferImage();
+  }
+
+  Image::ReleasePolicy releasePolicy =  Dali::Image::NEVER;
+  v8::Local releasePolicyValue = obj->Get( v8::String::NewFromUtf8( isolate, "releasePolicy" ) );
+  if( releasePolicyValue->IsUint32() )
+  {
+    releasePolicy = static_cast( releasePolicyValue->ToUint32()->Value() );
+  }
+
+  return FrameBufferImage::New( width, height, pixelFormat, releasePolicy );
+}
+
+} // FrameBufferImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/frame-buffer-image-api.h b/plugins/dali-script-v8/src/image/frame-buffer-image-api.h
new file mode 100644
index 0000000..ec0aaf3
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/frame-buffer-image-api.h
@@ -0,0 +1,47 @@
+#ifndef __DALI_V8PLUGIN_FRAME_BUFFER_IMAGE_API_H__
+#define __DALI_V8PLUGIN_FRAME_BUFFER_IMAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace FrameBufferImageApi
+{
+
+  /**
+   * Constructor
+   */
+  Image New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+}; // namespace FrameBufferImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_FRAME_BUFFER_IMAGE_API_H__
diff --git a/plugins/dali-script-v8/src/image/image-api.cpp b/plugins/dali-script-v8/src/image/image-api.cpp
new file mode 100644
index 0000000..e57d3a3
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-api.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "image-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+Image ImageApi::GetImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  ImageWrapper* wrapper = static_cast< ImageWrapper *>(ptr);
+  return wrapper->GetImage();
+}
+
+/**
+ * @constructor Image
+ * @method Image
+ * @for Image
+ * @return {Object} Image
+ */
+Image ImageApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  DALI_SCRIPT_EXCEPTION( isolate, "Image base class can not be constructed, try new dali.ResourceImage()");
+  return Image();
+}
+
+/**
+ * Return the image release policy
+ * @method getReleasePolicy
+ * @return dali.IMAGE_RELEASE_POLICY_UNUSED or dali.IMAGE_RELEASE_POLICY_NEVER
+ * @for Image
+ */
+void ImageApi::GetReleasePolicy( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Image image = GetImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetReleasePolicy() ) );
+}
+
+/**
+ * Return the image width in pixels
+ * @method getWidth
+ * @for Image
+ */
+void ImageApi::GetWidth( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Image image = GetImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetWidth() ) );
+}
+/**
+ * Return the image height in pixels
+ * @method getHeight
+ * @for Image
+ */
+void ImageApi::GetHeight( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Image image = GetImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetHeight() ) );
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/image-api.h b/plugins/dali-script-v8/src/image/image-api.h
new file mode 100644
index 0000000..4f62c81
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-api.h
@@ -0,0 +1,58 @@
+#ifndef __DALI_V8PLUGIN_IMAGE_API_H__
+#define __DALI_V8PLUGIN_IMAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ImageApi
+{
+
+  /**
+   * Helper to get image from args.This()
+   */
+  Image GetImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Constructor
+   */
+  Image New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Image API see image.h for a description
+   */
+  void GetReleasePolicy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetWidth( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetHeight( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace ImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_IMAGE_API_H__
diff --git a/plugins/dali-script-v8/src/image/image-attributes-api.cpp b/plugins/dali-script-v8/src/image/image-attributes-api.cpp
new file mode 100644
index 0000000..5e7006e
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-attributes-api.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "image-attributes-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+ImageAttributes ImageAttributesApi::GetImageAttributesFromObject( v8::Isolate* isolate, v8::Local object )
+{
+  v8::HandleScope handleScope( isolate);
+
+  if( BaseWrappedObject::IsWrappedType ( isolate, object, BaseWrappedObject::IMAGE_ATTRIBUTES ))
+  {
+    v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+    void* ptr = field->Value();
+    BaseWrappedObject* wrappedObject = static_cast< BaseWrappedObject *>(ptr);
+    ImageAttributesWrapper* wrapper = static_cast< ImageAttributesWrapper*>( wrappedObject );;
+    return  wrapper->GetImageAttributes();
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad image attributes url");
+    return ImageAttributes();
+  }
+
+}
+
+/***************************************
+ * IMAGE ATTRIBUTES FUNCTIONS
+ *
+ ****************************************/
+ImageAttributes ImageAttributesApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  // two combinations of constructor
+  // 1 = no parameters
+  // 2 = width, height
+  bool foundParams( false );
+  int params[2];
+
+  V8Utils::ReadIntegerArguments( foundParams, ¶ms[0],2,args,0);
+  if( !foundParams )
+  {
+    if( args.Length() != 0 )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, " ImageAttributes::New invalid params");
+      return Dali::ImageAttributes();
+    }
+    return Dali::ImageAttributes::New();
+  }
+  else
+  {
+    return  Dali::ImageAttributes::New( params[0], params[1] );
+  }
+
+}
+
+ImageAttributes& ImageAttributesApi::GetImageAttributes( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  ImageAttributesWrapper* wrapper = static_cast< ImageAttributesWrapper *>(ptr);
+  return wrapper->GetImageAttributes();
+}
+
+void ImageAttributesApi::SetSize( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  bool found;
+  Vector2 size = V8Utils::GetVector2Parameter( PARAMETER_0, found, isolate, args );
+  if (!found)
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid size parameter" );
+    return;
+  }
+  else
+  {
+    attribs.SetSize( size );
+  }
+}
+
+void ImageAttributesApi::SetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  bool found(false);
+  int value = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0);
+  if( !found  )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid scaling mode parameter");
+    return;
+  }
+  if( value!= ImageAttributes::ShrinkToFit ||
+      value!= ImageAttributes::ScaleToFill ||
+      value!= ImageAttributes::FitWidth ||
+      value!= ImageAttributes::FitHeight )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "invalid scaling mode parameter");
+     return;
+  }
+
+  attribs.SetScalingMode(static_cast( value) );
+}
+
+void ImageAttributesApi::SetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  bool parameterFound(false);
+  bool value = V8Utils::GetBooleanParameter( PARAMETER_0 , parameterFound, isolate, args );
+
+  if( !parameterFound )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter not found");
+    return;
+  }
+  attribs.SetOrientationCorrection( value );
+}
+
+void ImageAttributesApi::GetWidth( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, attribs.GetWidth() ) );
+}
+
+void ImageAttributesApi::GetHeight( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, attribs.GetHeight() ) );
+
+}
+
+void ImageAttributesApi::GetSize( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  Vector2 vec( attribs.GetSize() );
+  Dali::Property::Value value( vec );
+
+  v8::Local  object = PropertyValueWrapper::WrapDaliProperty( isolate, value);
+  args.GetReturnValue().Set(  object );
+}
+
+void ImageAttributesApi::GetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, attribs.GetScalingMode() ) );
+
+}
+
+void ImageAttributesApi::GetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ImageAttributes& attribs( GetImageAttributes( isolate, args ));
+
+  args.GetReturnValue().Set(  v8::Boolean::New(  isolate, attribs.GetOrientationCorrection() ) );
+
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/image-attributes-api.h b/plugins/dali-script-v8/src/image/image-attributes-api.h
new file mode 100644
index 0000000..c474ef0
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-attributes-api.h
@@ -0,0 +1,63 @@
+#ifndef __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_API_H__
+#define __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ImageAttributesApi
+{
+  ImageAttributes& GetImageAttributes( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  ImageAttributes GetImageAttributesFromObject( v8::Isolate* isolate, v8::Local object );
+
+  /**
+   * @brief Creates a new Image Attribute object based on some JavaScript parameters.
+   * @param[in] args constructor parameters
+   * @return ImageAttributes
+   */
+  ImageAttributes New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * ImageAttributes API see image-attributes.h for a description
+   */
+  void SetSize( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetWidth( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetHeight( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetSize( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetScalingMode( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetOrientationCorrection( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace ImageAttributesApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_API_H__
diff --git a/plugins/dali-script-v8/src/image/image-attributes-wrapper.cpp b/plugins/dali-script-v8/src/image/image-attributes-wrapper.cpp
new file mode 100644
index 0000000..fa89f79
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-attributes-wrapper.cpp
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "image-attributes-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+v8::Persistent ImageAttributesWrapper::mImageAttributesTemplate;
+
+namespace
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction ImageAttributeFunctionTable[]=
+{
+    /**************************************
+    * ImageAttributes API (in order of image-attributes.h)
+    **************************************/
+    { "SetSize",                    ImageAttributesApi::SetSize },
+    { "SetScalingMode",             ImageAttributesApi::SetScalingMode },
+    { "SetOrientationCorrection",   ImageAttributesApi::SetOrientationCorrection },
+    { "GetWidth",                   ImageAttributesApi::GetWidth },
+    { "GetHeight",                  ImageAttributesApi::GetHeight },
+    { "GetSize",                    ImageAttributesApi::GetSize },
+    { "GetScalingMode",             ImageAttributesApi::GetScalingMode },
+    { "GetOrientationCorrection",   ImageAttributesApi::GetOrientationCorrection },
+};
+
+const unsigned int ImageAttributeFunctionTableCount = sizeof(ImageAttributeFunctionTable)/sizeof(ImageAttributeFunctionTable[0]);
+} //un-named space
+
+
+ImageAttributesWrapper::ImageAttributesWrapper( const Dali::ImageAttributes& imageAttributes, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::IMAGE_ATTRIBUTES , gc )
+{
+    mImageAttributes = imageAttributes;
+}
+
+v8::Handle ImageAttributesWrapper::WrapImageAttributes(v8::Isolate* isolate, const Dali::ImageAttributes& attributes )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetImageAttributesTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the ImageAttributes wrapper
+  ImageAttributesWrapper* pointer =  new ImageAttributesWrapper( attributes, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local ImageAttributesWrapper::GetImageAttributesTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+
+  if( mImageAttributesTemplate.IsEmpty() )
+  {
+    objectTemplate = MakeImageAttributesTemplate( isolate );
+    mImageAttributesTemplate.Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, mImageAttributesTemplate );
+  }
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle ImageAttributesWrapper::MakeImageAttributesTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, ImageAttributeFunctionTable, ImageAttributeFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+void ImageAttributesWrapper::NewImageAttributes( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if(!args.IsConstructCall())
+  {
+      DALI_SCRIPT_EXCEPTION(isolate, "ImageAttributes constructor called without 'new'");
+      return;
+  }
+
+  // attribs can be passed by value
+  Dali::ImageAttributes attribs = ImageAttributesApi::New( args );
+  v8::Local localObject = WrapImageAttributes( isolate, attribs );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+ImageAttributes& ImageAttributesWrapper::GetImageAttributes()
+{
+  return mImageAttributes;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/image-attributes-wrapper.h b/plugins/dali-script-v8/src/image/image-attributes-wrapper.h
new file mode 100644
index 0000000..91511ea
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-attributes-wrapper.h
@@ -0,0 +1,85 @@
+#ifndef __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_WRAPPER_H__
+#define __DALI_V8PLUGIN_IMAGE_ATTRIBUTES_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An Image Attributes wrapper.
+ * Provides access to ImageAttributes specific functionality and V8 memory handling.
+ */
+class ImageAttributesWrapper : public BaseWrappedObject
+{
+
+public:
+
+  /**
+   * Constructor
+   */
+  ImageAttributesWrapper( const ImageAttributes& imageAttributes,
+                GarbageCollectorInterface& gc );
+
+  /**
+    * Destructor
+    */
+  virtual ~ImageAttributesWrapper(){};
+
+  /**
+   * Constructors
+   */
+  static void NewImageAttributes( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps an image attributes
+   */
+  static v8::Handle WrapImageAttributes(v8::Isolate* isolate, const Dali::ImageAttributes& attributes);
+
+
+  // The ImageAttribute ObjectTemplate, we cache templates so we don't have
+  // keep generating them everytime we want to create an ImageAttribute
+  static v8::Persistent mImageAttributesTemplate;
+
+  ImageAttributes& GetImageAttributes();
+private:
+
+  // ImageAttributes
+  ImageAttributes mImageAttributes;
+
+  static v8::Handle MakeImageAttributesTemplate( v8::Isolate* isolate );
+  static v8::Local GetImageAttributesTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/image/image-wrapper.cpp b/plugins/dali-script-v8/src/image/image-wrapper.cpp
new file mode 100644
index 0000000..f4da93e
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-wrapper.cpp
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "image-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+v8::Persistent ImageWrapper::mImageTemplate;
+v8::Persistent ImageWrapper::mResourceImageTemplate;
+v8::Persistent ImageWrapper::mNinePatchImageTemplate;
+v8::Persistent ImageWrapper::mBufferImageTemplate;
+v8::Persistent ImageWrapper::mFrameBufferImageTemplate;
+v8::Persistent ImageWrapper::mNativeImageTemplate;
+
+/**
+ * pointer to a persistent template handle
+ */
+struct ImageTemplate
+{
+  v8::Persistent* imageTemplate;
+};
+
+/**
+ * array of templates for each type of image
+ */
+const ImageTemplate ImageTemplateLookup[]=
+{
+    { &ImageWrapper::mImageTemplate },              // IMAGE
+    { &ImageWrapper::mResourceImageTemplate },      // RESOURCE_IMAGE
+    { &ImageWrapper::mNinePatchImageTemplate },     // NINE PATCH IMAGE
+    { &ImageWrapper::mBufferImageTemplate  },       // BITMAP_IMAGE
+    { &ImageWrapper::mFrameBufferImageTemplate },   // FRAME_BUFFER_IMAGE
+    { &ImageWrapper::mNativeImageTemplate },        // NATIVE_IMAGE
+
+};
+
+
+namespace // un-named name space
+{
+
+/**
+ * Bitmask of API's that an image can support
+ */
+enum ImageApiBitMask
+{
+  IMAGE_API              = 1 << 0,
+  BITMAP_IMAGE_API       = 1 << 1,
+  RESOURCE_IMAGE_API     = 1 << 2,
+  NINE_PATCH_IMAGE_API   = 1 << 3,
+  FRAME_BUFFER_IMAGE_API = 1 << 4,
+  NATIVE_IMAGE_API       = 1 << 5,
+
+};
+
+/**
+ * structure used for the ImageApiLookup.
+ */
+struct ImageApiStruct
+{
+  const char* imageName;                  ///< name of the image, used to find out what type of image to construct
+  ImageWrapper::ImageType imageType;      ///< image type
+  Image (*constructor)( const v8::FunctionCallbackInfo< v8::Value >& args); ///< constructor
+  int supportApis;                        ///< supported API's
+};
+
+/**
+ * Lookup table to match a image type with a constructor and supported API's.
+ */
+const ImageApiStruct ImageApiLookup[]=
+{
+  {"Image",           ImageWrapper::IMAGE,              ImageApi::New,            IMAGE_API },
+  {"ResourceImage",   ImageWrapper::RESOURCE_IMAGE,     ResourceImageApi::New,    IMAGE_API | RESOURCE_IMAGE_API },
+  {"NinePatchImage",  ImageWrapper::NINE_PATCH_IMAGE,   NinePatchImageApi::New,   IMAGE_API | RESOURCE_IMAGE_API | NINE_PATCH_IMAGE_API },
+  {"BufferImage",     ImageWrapper::BITMAP_IMAGE,       BufferImageApi::New,      IMAGE_API | BITMAP_IMAGE_API },
+  {"FrameBufferImage",ImageWrapper::FRAME_BUFFER_IMAGE, FrameBufferImageApi::New, IMAGE_API | FRAME_BUFFER_IMAGE_API },
+  {"NativeImage",     ImageWrapper::NATIVE_IMAGE,       NativeImageApi::New,      IMAGE_API | NATIVE_IMAGE_API },
+
+};
+
+const unsigned int ImageApiLookupCount = sizeof(ImageApiLookup)/sizeof(ImageApiLookup[0]);
+
+
+/**
+ * given an image type return what api's it supports
+ */
+int GetImageSupportedApis( ImageWrapper::ImageType type )
+{
+  return ImageApiLookup[ type].supportApis;
+}
+
+/**
+ * Used for the ImageFunctionTable to map function names to functions
+ * with for a specific API
+ */
+struct ImageFunctions
+{
+  const char* name;               ///< function name
+  void (*function)( const v8::FunctionCallbackInfo< v8::Value >& args);
+  ImageApiBitMask api;
+};
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ImageFunctions ImageFunctionTable[]=
+{
+    /**************************************
+    * Image API (in order of image.h)
+    **************************************/
+    { "GetWidth",                ImageApi::GetWidth , IMAGE_API },
+    { "GetHeight",               ImageApi::GetHeight, IMAGE_API },
+    { "GetReleasePolicy",        ImageApi::GetReleasePolicy, IMAGE_API },
+
+    // resource-image API
+    { "GetLoadingState",         ResourceImageApi::GetLoadingState,     RESOURCE_IMAGE_API },
+    { "GetUrl",                  ResourceImageApi::GetUrl,              RESOURCE_IMAGE_API },
+    { "GetLoadPolicy",           ResourceImageApi::GetLoadPolicy,       RESOURCE_IMAGE_API },
+    { "Reload",                  ResourceImageApi::Reload,              RESOURCE_IMAGE_API },
+
+    // nine-patch API
+    { "GetStretchBorders",       NinePatchImageApi::GetStretchBorders,        NINE_PATCH_IMAGE_API },
+    { "GetChildRectangle",       NinePatchImageApi::GetChildRectangle,        NINE_PATCH_IMAGE_API },
+    { "CreateCroppedBufferImage",NinePatchImageApi::CreateCroppedBufferImage, NINE_PATCH_IMAGE_API },
+
+    // buffer image API
+    { "GetBuffer",              BufferImageApi::GetBuffer,           BITMAP_IMAGE_API },
+    { "GetBufferSize",          BufferImageApi::GetBufferSize,       BITMAP_IMAGE_API },
+    { "GetBufferStride",        BufferImageApi::GetBufferStride,     BITMAP_IMAGE_API },
+    { "GetPixelFormat",         BufferImageApi::GetPixelFormat,      BITMAP_IMAGE_API },
+    { "Update",                 BufferImageApi::Update,              BITMAP_IMAGE_API },
+    { "IsDataExternal",         BufferImageApi::IsDataExternal,      BITMAP_IMAGE_API },
+
+    // Frame buffer image has no API
+    // Native image has no API
+
+};
+
+const unsigned int ImageFunctionTableCount = sizeof(ImageFunctionTable)/sizeof(ImageFunctionTable[0]);
+} //un-named space
+
+
+ImageWrapper::ImageWrapper( const Dali::Image& image, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::IMAGE , gc )
+{
+    mImage = image;
+}
+
+v8::Handle ImageWrapper::WrapImage(v8::Isolate* isolate, const Dali::Image& image )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local object = WrapImage( isolate, image, GetImageType( image.GetTypeName() ) );
+
+  return handleScope.Escape( object );
+}
+v8::Handle ImageWrapper::WrapImage(v8::Isolate* isolate, const Dali::Image& image, ImageType imageType )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetImageTemplate( isolate, imageType);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the Image wrapper
+  ImageWrapper* pointer =  new ImageWrapper( image, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  // This also stores the Image object, in an internal field inside the JavaScript object.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local ImageWrapper::GetImageTemplate( v8::Isolate* isolate, ImageType imageType )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  if( ImageTemplateLookup[ imageType ].imageTemplate->IsEmpty() )
+  {
+    objectTemplate = MakeImageTemplate( isolate, imageType );
+    ImageTemplateLookup[ imageType ].imageTemplate->Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, *ImageTemplateLookup[ imageType ].imageTemplate );
+  }
+
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle ImageWrapper::MakeImageTemplate( v8::Isolate* isolate, ImageType imageType )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add intercepts for Signals on ResourceImage, we can't use HandleWrapper::AddIntercepts because Image doesn't inherit
+  // from Handle ( just baseHandle)
+  if (( imageType == RESOURCE_IMAGE ) ||
+      ( imageType == NINE_PATCH_IMAGE ))
+  {
+     ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
+  }
+
+  // find out what API's this image supports
+  int supportApis = GetImageSupportedApis( imageType );
+
+  // add our function properties
+  for( unsigned int i = 0; i < ImageFunctionTableCount; ++i )
+  {
+    const ImageFunctions property =  ImageFunctionTable[i];
+
+    // check to see if the image supports a certain type of API
+    // e.g. Bitmap will support IMAGE_API and BITMAP_IMAGE_API
+    if( supportApis &  property.api )
+    {
+      std::string funcName = V8Utils::GetJavaScriptFunctionName( property.name);
+
+      objTemplate->Set( v8::String::NewFromUtf8(   isolate, funcName.c_str() ),
+                      v8::FunctionTemplate::New( isolate, property.function ) );
+    }
+  }
+
+  return handleScope.Escape( objTemplate );
+}
+
+
+void ImageWrapper::NewImage( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if(!args.IsConstructCall())
+  {
+      DALI_SCRIPT_EXCEPTION( isolate, "Image constructor called without 'new'");
+      return;
+  }
+
+  // find out the callee function name...e.g. BufferImage, ResourceImage
+  v8::Local callee = args.Callee();
+  v8::Local v8String = callee->GetName();
+  std::string typeName = V8Utils::v8StringToStdString( v8String );
+
+  ImageType imageType = GetImageType( typeName );
+
+  if( imageType == UNKNOWN_IMAGE_TYPE )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "unknown image type");
+    return;
+  }
+  Image image = (ImageApiLookup[imageType].constructor)( args );
+
+  if( ! image )
+  {
+    // a v8 exception will have been thrown by the constructor
+    return;
+  }
+
+  v8::Local localObject = WrapImage( isolate, image, imageType );
+
+  args.GetReturnValue().Set( localObject );
+}
+
+Image ImageWrapper::GetImage()
+{
+  return mImage;
+}
+
+/**
+ * given an image type name, e.g. returns the type, e.g. ImageWrapper::BITMAP_IMAGE
+ */
+ImageWrapper::ImageType ImageWrapper::GetImageType( const std::string& name )
+{
+  for( unsigned int i = 0 ; i < ImageApiLookupCount ; i++ )
+  {
+    if( strncmp( ImageApiLookup[i].imageName, name.c_str(), name.length() ) == 0 )
+    {
+      return ImageApiLookup[i].imageType;
+    }
+  }
+  return ImageWrapper::UNKNOWN_IMAGE_TYPE;
+}
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/image-wrapper.h b/plugins/dali-script-v8/src/image/image-wrapper.h
new file mode 100644
index 0000000..7644b00
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/image-wrapper.h
@@ -0,0 +1,130 @@
+#ifndef __DALI_V8PLUGIN_IMAGE_WRAPPER_H__
+#define __DALI_V8PLUGIN_IMAGE_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An Image  wrapper.
+ * Provides access to Image specific functionality and V8 memory handling.
+ */
+class ImageWrapper : public BaseWrappedObject
+{
+
+public:
+
+  /**
+   * Image type used an index,
+   * please update the table in ImageApiLookup if this list changes ( the enum is used as an index)
+   */
+  enum ImageType
+  {
+    UNKNOWN_IMAGE_TYPE = -1,
+    IMAGE               = 0,
+    RESOURCE_IMAGE      = 1,
+    NINE_PATCH_IMAGE    = 2,
+    BITMAP_IMAGE        = 3,
+    FRAME_BUFFER_IMAGE  = 4,
+    NATIVE_IMAGE        = 5
+   };
+
+  /**
+   * Constructor
+   */
+  ImageWrapper( const Image& image,
+                GarbageCollectorInterface& gc );
+
+  /**
+   * Destructor
+   */
+  virtual ~ImageWrapper()
+  {
+  };
+
+  /**
+   * @brief Creates a new Image wrapped inside a Javascript Object.
+   * @note: the actor type ie 'ImageImage' is expected to be the name of the callee function.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewImage( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps an image of a given type
+   */
+  static v8::Handle WrapImage(v8::Isolate* isolate, const Dali::Image& image, ImageType imageType );
+
+  /**
+   * Wraps an image, the type is looked up from the image
+   */
+  static v8::Handle WrapImage(v8::Isolate* isolate, const Dali::Image& image );
+
+  /**
+   * @return Image
+   */
+  Image GetImage();
+
+  /**
+   * @return signal manager pointer
+   */
+  virtual SignalManager* GetSignalManager() { return &mSignalManager;}
+
+  // The Image ObjectTemplate, we cache templates so we don't have
+  // keep generating them everytime we want to create an Image
+  static v8::Persistent mImageTemplate;
+  static v8::Persistent mResourceImageTemplate;
+  static v8::Persistent mNinePatchImageTemplate;
+  static v8::Persistent mBufferImageTemplate;
+  static v8::Persistent mFrameBufferImageTemplate;
+  static v8::Persistent mNativeImageTemplate;
+
+private:
+
+  /**
+   * Helper
+   */
+  static ImageType GetImageType( const std::string& name );
+
+  static v8::Handle MakeImageTemplate( v8::Isolate* isolate, ImageType imageType );
+  static v8::Local GetImageTemplate( v8::Isolate* isolate , ImageType imageType );
+
+
+  Image mImage;                     ///< Image handle
+  SignalManager mSignalManager;     ///< Signal Manager
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_IMAGE_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/image/native-image-api.cpp b/plugins/dali-script-v8/src/image/native-image-api.cpp
new file mode 100644
index 0000000..a09ebca
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/native-image-api.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "frame-buffer-image-api.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace NativeImageApi
+{
+
+/**
+ * ## NativeImage **Not Supported**
+ * NativeImage represents an image resource that can be added to ImageActors.
+ * Its data is provided by native resources, such as shared bitmap memory or pixmap from X11 or ECORE-X11, etc.
+ * @class NativeImage
+ * @extends Image
+ */
+
+/**
+ * **Currently not supported. This is a Place holder**
+ * @constructor
+ * @method NativeImage
+ * @for NativeImage
+ * @return {Object} Image
+ */
+Image New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  // return empty image handle
+  return NativeImage();
+}
+
+} // NativeImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/native-image-api.h b/plugins/dali-script-v8/src/image/native-image-api.h
new file mode 100644
index 0000000..609cc39
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/native-image-api.h
@@ -0,0 +1,47 @@
+#ifndef __DALI_V8PLUGIN_NATIVE_IMAGE_API_H__
+#define __DALI_V8PLUGIN_NATIVE_IMAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace NativeImageApi
+{
+
+  /**
+   * Constructor
+   */
+  Image New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+}; // namespace NativeImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_NATIVE_IMAGE_API_H__
diff --git a/plugins/dali-script-v8/src/image/nine-patch-image-api.cpp b/plugins/dali-script-v8/src/image/nine-patch-image-api.cpp
new file mode 100644
index 0000000..ddef365
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/nine-patch-image-api.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "nine-patch-image-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ *
+ * NinePatchImage represents an image resource that can be added to ImageActors.
+ * It contains a bitmap that is synchronously loaded from the file system that contains
+ * a 9 patch border - a 1 pixel border that describes the stretch borders and the child
+ * area.
+ *
+ * The class offers an API to read the stretch area and child area, but it does not
+ * remove the border from it's bitmap. An API can be used to obtain a BufferImage with
+ * the border removed.
+ *
+ * Adding this image to an ImageActor using an Image handle will automatically convert
+ * to use the cropped BufferImage - if you don't retain a handle to this object, it will
+ * be automatically destroyed.
+ * @class NinePatchImage
+ * @extends ResourceImage
+ */
+
+NinePatchImage NinePatchImageApi::GetNinePatchImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  ImageWrapper* wrapper = static_cast< ImageWrapper *>(ptr);
+  return NinePatchImage ::DownCast( wrapper->GetImage() );
+}
+
+
+/**
+ * Create a new nine patch image object.
+ *
+ * @constructor
+ * @method NinePatchImage
+ * @for NinePatchImage
+ * @param {Object} options
+ * @param {String} options.url The URL of the nine patch image file to use.
+ * @return {Object} Image
+ */
+Image NinePatchImageApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  std::string url;
+  v8::Local options( args[0] );
+
+  if( !options->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing params");
+    return NinePatchImage();
+  }
+
+  v8::Local optionsObject = options->ToObject();
+
+  v8::Local urlValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "url" ) );
+  if( urlValue->IsString() )
+  {
+    url = V8Utils::v8StringToStdString( urlValue );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing url");
+    return NinePatchImage();
+  }
+
+  return NinePatchImage::New( url );
+}
+
+
+/**
+ * Get the Stretch Borders
+ *
+ * @method getStretchBorders
+ * @for NinePatchImage
+ * @return object containing x,y,w,h properties
+ */
+void NinePatchImageApi::GetStretchBorders( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  NinePatchImage image = GetNinePatchImage( isolate, args );
+
+  v8::Local rectObject = v8::Object::New( isolate );
+
+  Vector4 borders = image.GetStretchBorders();
+  // Set the direction
+
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "x" ), v8::Integer::New( isolate,borders.x ) );
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "y" ), v8::Integer::New( isolate,borders.y ) );
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "w" ), v8::Integer::New( isolate,borders.z ) );
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "h" ), v8::Integer::New( isolate,borders.w ) );
+
+  args.GetReturnValue().Set( rectObject );
+}
+
+/**
+ * Get the child rectangle
+ * @method getChildRectangle
+ * @for NinePatchImage
+ * @return {Object} position/size of of the child rectangle with x,y,w,h properties
+ *
+ */
+void NinePatchImageApi::GetChildRectangle( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  NinePatchImage image = GetNinePatchImage( isolate, args );
+
+  v8::Local rectObject = v8::Object::New( isolate );
+  Rect childRect = image.GetChildRectangle();
+
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "x" ), v8::Integer::New( isolate,childRect.x ) );
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "y" ), v8::Integer::New( isolate,childRect.y ) );
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "w" ), v8::Integer::New( isolate,childRect.width ) );
+  rectObject->Set( v8::String::NewFromUtf8( isolate, "h" ), v8::Integer::New( isolate,childRect.height ) );
+
+  args.GetReturnValue().Set( rectObject );
+}
+
+/**
+ * Creates a buffer image from the bitmap with the 1 pixel border cropped off.
+ * This does not change the internal bitmap.
+ * @method createCroppedBufferImage
+ * @for NinePatchImage
+ */
+void NinePatchImageApi::CreateCroppedBufferImage( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Image image = GetNinePatchImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetWidth() ) );
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/nine-patch-image-api.h b/plugins/dali-script-v8/src/image/nine-patch-image-api.h
new file mode 100644
index 0000000..3f1cf40
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/nine-patch-image-api.h
@@ -0,0 +1,58 @@
+#ifndef __DALI_V8PLUGIN_NINE_PATCH_IMAGE_API_H__
+#define __DALI_V8PLUGIN_NINE_PATCH_IMAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace NinePatchImageApi
+{
+  /**
+   * Helper
+   */
+  NinePatchImage GetNinePatchImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Constructor
+   */
+  Image New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Ninepatch Image API see nine-patch-image.h for a description
+   */
+  void GetStretchBorders( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetChildRectangle( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void CreateCroppedBufferImage( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace NinePatchImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_NINE_PATCH_IMAGE_API_H__
diff --git a/plugins/dali-script-v8/src/image/resource-image-api.cpp b/plugins/dali-script-v8/src/image/resource-image-api.cpp
new file mode 100644
index 0000000..fe4ff2a
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/resource-image-api.cpp
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "resource-image-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+ResourceImage ResourceImageApi::GetResourceImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  ImageWrapper* wrapper = static_cast< ImageWrapper *>(ptr);
+  return ResourceImage::DownCast( wrapper->GetImage() );
+}
+
+/**
+ * Create a new resource image object.
+ *
+ * @constructor
+ * @method ResourceImage
+ * @for ResourceImage
+ * @param {Object} options
+ * @param {String} options.url The URL of the image file to use.
+ * @param {Object} [option.imageAttributes] image attributes object
+ * @param {Integer} [options.loadPolicy] The LoadPolicy to apply when loading the image resource.
+ * @param {Integer} [options.releasePolicy] optionally release memory when image is not visible on screen.
+ * @return {Object} Image
+ */
+Image ResourceImageApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  std::string url;
+  ResourceImage::LoadPolicy loadPolicy( ResourceImage::IMMEDIATE );
+  Image::ReleasePolicy releasePolicy( Image::NEVER);
+  ImageAttributes imageAttributes;
+  bool useImageAttributes = false;
+
+  v8::Local options( args[0] );
+
+  if( !options->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing params" );
+    return Image();
+  }
+
+  v8::Local optionsObject = options->ToObject();
+
+  v8::Local urlValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "url" ) );
+  if( urlValue->IsString() )
+  {
+    url = V8Utils::v8StringToStdString( urlValue );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing url");
+    return Image();
+  }
+
+  v8::Local imageAttribsValue= optionsObject->Get( v8::String::NewFromUtf8( isolate, "imageAttributes" ) );
+  if( imageAttribsValue->IsObject() )
+  {
+    imageAttributes = ImageAttributesApi::GetImageAttributesFromObject( isolate, imageAttribsValue->ToObject() );
+  }
+
+
+
+  v8::Local releasePolicyValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "releasePolicy" ) );
+  if( releasePolicyValue->IsUint32() )
+  {
+    releasePolicy = static_cast( releasePolicyValue->ToUint32()->Value() );
+  }
+
+  v8::Local loadPolicyValue = optionsObject->Get( v8::String::NewFromUtf8( isolate, "loadPolicy" ) );
+  if( loadPolicyValue->IsUint32() )
+  {
+    loadPolicy = static_cast< ResourceImage::LoadPolicy >( loadPolicyValue->ToUint32()->Value());
+  }
+
+  if( useImageAttributes )
+  {
+    return ResourceImage::New( url, imageAttributes, loadPolicy, releasePolicy);
+  }
+  else
+  {
+    return ResourceImage::New( url, loadPolicy, releasePolicy);
+  }
+}
+
+/**
+ * Get the load policy
+ *
+ * @method getLoadPolicy
+ * @for ResourceImage
+ * @return {Integer} load policy either dali.IMAGE_LOAD_POLICY_ON_DEMAND or dali.IMAGE_LOAD_POLICY_IMMEDIATE
+ */
+void ResourceImageApi::GetLoadPolicy( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  ResourceImage image = GetResourceImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetLoadPolicy() ) );
+}
+
+/**
+ * Query whether the image data has loaded.
+ *
+ * The asynchronous loading begins when the Image object is created.
+ * After the Image object is discarded, the image data will be released from memory
+ * this will occur when the object is garbage collected.
+ * @method getLoadPolicy
+ * @for ResourceImage
+ * @return {Integer} loading state either dali.RESOURCE_LOADING, dali.RESOURCE_LOADING_SUCCEEDED or dali.RESOUCE_LOADING_FAILED
+ */
+void ResourceImageApi::GetLoadingState( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  ResourceImage image = GetResourceImage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, image.GetLoadingState() ) );
+}
+
+/**
+ * Return the image url
+ *
+ * @method getUrl
+ * @for ResourceImage
+ * @return {String} filename
+ */
+void ResourceImageApi::GetUrl( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  ResourceImage image = GetResourceImage( isolate, args );
+
+  v8::Local v8String = v8::String::NewFromUtf8( isolate, image.GetUrl().c_str() );
+  args.GetReturnValue().Set( v8String  );
+}
+
+
+/**
+ * Reload the image
+ * The set ImageAttributes are used when requesting the image again.
+ * @note if Image is offstage and OnDemand policy is set, reload request is ignored.
+ * @method reload
+ * @for ResourceImage
+ */
+void ResourceImageApi::Reload( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  ResourceImage image = GetResourceImage( isolate, args );
+  image.Reload();
+}
+
+
+/**
+ * Return attributes for the image
+ * Only to be used after the image has finished loading.
+ * (Ticket's LoadingSucceeded callback was called)
+ * The returned value will reflect the true image dimensions once the asynchronous loading has finished.
+ *
+ * @method getAttributes
+ * @for ResourceImage
+ * @return {Object} ImageAttributes
+ */
+void ResourceImageApi::GetAttributes( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  ResourceImage image = GetResourceImage( isolate, args );
+
+  v8::Local localObject = ImageAttributesWrapper::WrapImageAttributes(isolate, image.GetAttributes());
+
+  args.GetReturnValue().Set( localObject );
+}
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/image/resource-image-api.h b/plugins/dali-script-v8/src/image/resource-image-api.h
new file mode 100644
index 0000000..46d7d13
--- /dev/null
+++ b/plugins/dali-script-v8/src/image/resource-image-api.h
@@ -0,0 +1,60 @@
+#ifndef __DALI_V8PLUGIN_RESOURCE_IMAGE_API_H__
+#define __DALI_V8PLUGIN_RESOURCE_IMAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ResourceImageApi
+{
+  /**
+   * Helper
+   */
+  ResourceImage GetResourceImage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Constructor
+   */
+  Image New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * Resource Image API see resource-image.h for a description
+   */
+  void GetLoadPolicy( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetLoadingState( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetUrl( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Reload( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetAttributes( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace ResourceImageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_RESOURCE_IMAGE_API_H__
diff --git a/plugins/dali-script-v8/src/interfaces/garbage-collector-interface.h b/plugins/dali-script-v8/src/interfaces/garbage-collector-interface.h
new file mode 100644
index 0000000..77e83a9
--- /dev/null
+++ b/plugins/dali-script-v8/src/interfaces/garbage-collector-interface.h
@@ -0,0 +1,97 @@
+#ifndef __DALI_V8PLUGIN_GARBAGE_COLLECTOR_INTERFACE_H__
+#define __DALI_V8PLUGIN_GARBAGE_COLLECTOR_INTERFACE_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+class BaseWrappedObject;
+
+/**
+ * @brief Tracks all Dali-wrapped objects that are used by v8.
+ * Required to delete any wrapped objects that are not cleaned up after V8 has shut down.
+ *
+ * Unfortunately the v8 garbage collection may never run while executing a script,
+ * and currently doesn't run on shutdown (for performance reasons with Chrome browser).
+ *
+ * This means we have to manually keep track of all objects, and perform our
+ * own garbage collection on shut down.
+ *
+ * For every object created:
+ * - Store a weak handle to it
+ * - Register a callback to be informed if v8 garbage collector decides it's no longer required.
+ * -- Call back is done using v8 SetWeak(), which states:
+ *    "There is no guarantee as to *when* or even *if* the callback is invoked."
+ *
+ */
+class GarbageCollectorInterface
+{
+
+public:
+
+  /**
+   * Register an object with Dali's garbage collector
+   * @param object a wrapped object
+   */
+  virtual void Register( BaseWrappedObject* object ) = 0;
+
+  /**
+   * Un-register an object with Dali's garbage collector
+   * @param object a wrapped object
+   */
+  virtual void UnRegister( BaseWrappedObject* object )  = 0;
+
+  /**
+   * Delete all
+   */
+  virtual void GarbageCollect() = 0;
+
+protected:
+
+  /**
+   * Constructor
+   */
+  GarbageCollectorInterface()
+  {
+  }
+
+  /**
+   * virtual destructor
+   */
+  virtual ~GarbageCollectorInterface()
+  {
+  }
+
+  // Undefined copy constructor.
+  GarbageCollectorInterface( const GarbageCollectorInterface& );
+
+  // Undefined assignment operator.
+  GarbageCollectorInterface& operator=( const GarbageCollectorInterface& );
+
+
+};
+
+} // V8Plugin
+
+} // Dali
+
+#endif // header __DALI_V8PLUGIN_GARBAGE_COLLECTOR_INTERFACE_H__
diff --git a/plugins/dali-script-v8/src/module-loader/module-loader.cpp b/plugins/dali-script-v8/src/module-loader/module-loader.cpp
new file mode 100644
index 0000000..c9d58ea
--- /dev/null
+++ b/plugins/dali-script-v8/src/module-loader/module-loader.cpp
@@ -0,0 +1,426 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "module-loader.h"
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+ModuleLoader::ModuleLoader()
+{
+
+}
+
+ModuleLoader::~ModuleLoader()
+{
+  VectorBase::SizeType count =  mModules.Count();
+  for( VectorBase::SizeType  i = 0; i < count ; ++i)
+  {
+    Module* module = mModules[i];
+    delete module;
+  }
+  mModules.Clear();
+}
+
+bool ModuleLoader::CompileAndRun(v8::Isolate* isolate,
+    const std::string& sourceCode,
+    const std::string& sourceFileName )
+{
+
+  v8::HandleScope handleScope( isolate );
+  v8::TryCatch tryCatch;
+
+  // convert from string to v8 string
+  v8::Local source = v8::String::NewFromUtf8( isolate, sourceCode.c_str());
+  v8::Local file = v8::String::NewFromUtf8( isolate, sourceFileName.c_str());
+  v8::ScriptOrigin origin(file);
+
+  // Compile the script
+  v8::Local script = v8::Script::Compile( source, &origin);
+
+  // See if an exception has been thrown
+  if( tryCatch.HasCaught() || script.IsEmpty() )
+  {
+    // Print errors that happened during compilation.
+    V8Utils::ReportException( isolate, &tryCatch );
+    return false;
+  }
+
+  // Run the script
+  v8::Local result = script->Run();
+
+  // in V8 test code ( they check for an exception and empty return object )
+  if( tryCatch.HasCaught() || result.IsEmpty() )
+  {
+    // Print errors that happened during execution.
+    V8Utils::ReportException( isolate, &tryCatch);
+    return false;
+  }
+
+  return true;
+}
+
+bool ModuleLoader::ExecuteScript( v8::Isolate* isolate,
+                                  const std::string& sourceCode,
+                                  const std::string& sourceFileName )
+{
+  StoreScriptInfo(  sourceFileName );
+
+  return CompileAndRun(isolate, sourceCode, sourceFileName );
+}
+
+bool ModuleLoader::ExecuteScriptFromFile( v8::Isolate* isolate,
+                                          const std::string& fileName  )
+{
+  std::string contents;
+
+  V8Utils::GetFileContents( fileName, contents );
+
+  return ExecuteScript( isolate, contents, fileName );
+}
+
+/**
+ * ### var module = require("module-name");
+ *
+ *
+ * There is no standard for modules or the 'require' keyword in JavaScript.
    
+ * However CommonJS have this: http://wiki.commonjs.org/wiki/Modules/1.1.1  ( used by Node.js).
+ * 
     
    
+ *
+ * The concept behind 'require' keyword is simple, it allows you to include another
+ * JavaScript file, which exports an API / function / constructor / singleton.
+ *
+ *
+ *     // example_module.js
+ *     exports.hello = function() { return "hello world" }
+ *
+ * 
    
+ *
+ *     // main.js
+ *     var example = require( "example_module.js");
+ *
+ *     log( example.hello() );
+ *
+ *
+
+ * ### Module writers guide:
+ *
+ *
+ * #### Exporting as a namespace
+ *
+ * Example of using a namespace to export functions / objects.
+ *
+ *     // filesystem-helper.js
+ *     exports.version = "FileSystem helper 1.0";
+ *     exports.open = function() { }
+ *     exports.close = function() { }
+ *     exports.read = function() { }
+ *     exports.write = function() { ... }
+ *     exports.fileSize = function() {...}
+ *
+ * 
    
+ *
+ *     // main.js
+ *     var fs = require( "filesystem-helper.js");
+ *
+ *     log( fs.version );
+ *
+ *     var file = fs.open("myfile.txt");
+ *     var data = fs.read( file );
+ *
+ *
+ *
+ * #### Exporting as a function
+ *
+ * In this example we are using module.exports directly to change it
+ * from an object literal with name-value pairs (exports object) to a function.
+ *
+ *     // my_first_module.js
+ *     module.exports = function() {  log("hello-world"); }
+ *
+ * 
    
+ *
+ *     // main.js
+ *     var func = require("my_first_module.js");
+ *     func();      // prints out hello-world
+ *
+ *
+ * #### Exporting as a constructor
+ *
+ *
+ *     // ImageActor.js
+ *     function ImageActor( position, rotation, image, name )
+ *     {
+ *         this = new dali.ImageActor( image );
+ *         this.position = position;
+ *         this.rotation = rotation;
+ *         this.name = name;
+ *     }
+ *     module.exports = ImageActor;
+ *
+ * 
    
+ *
+ *     // main.js
+ *
+ *     var ImageActor = require(" ImageActor.js");
+ *
+ *     var imageActor = new ImageActor( position, rotation, image, "my first image actor");
+ *
+ * #### Exporting as a singleton
+ *
+ * By exporting a singleton you have an object which has shared state between
+ * any modules using it.
+ *
+ * example:
+ *
+ *     // image-database.js
+ *
+ *     function ImageDatabase( )
+ *     {
+ *       this.addImage  = function() {  ... };
+ *       this.removeImage = function() { ... };
+ *       this.getImage = function()  { ...};
+ *       this.getImageCount = function() { ... };
+ *     }
+ *
+ *     module.exports = new ImageDatabase();
+ *
+ *
+ * 
    
+ *
+ *     // main.js
+ *
+ *     var database = require('image-database.js');
+ *
+ *     database.addImage( myImage );
+ *
+ * 
    
+ *
+ *     // another-module.js
+ *     var database = require('image-database.js');
+ *
+ *     // gets the same database object as main.js
+ *
+ *
+ * The first call to require('image-database.js') will create the image database.
+ * Further calls, will return the same instance, because require caches module.exports.
+ * Otherwise it would have to recompile and run the module every time require is called.
+ *
+ * ## Notes
+ *
+ * #### Automatic wrapping of a module by DALi:
+ *
+ * The module is automatically wrapped in a function by DALi before being executed ( similar technique to Node.js). 
    
+ * This is to prevent any functions / variables declared by the module entering the global namespace. 
    
+ * Currently the module will have access to all DALi global functions, like log, require and the DALi API ( actors / stage etc).
    
+ *
+ *
+ *     // Parameters passed to the internally generated function
+ *     // module = reference to current module
+ *     // module.exports = defines what the module exports
+ *     // exports = reference to module.exports
+ *     // __filename = module filename
+ *     // __dirname = module directory
+ *
+ *     function createModuleXYZ( exports ( === module.exports), module, __filename, __dirname )
+ *     {
+ *       //
+ *       // Module code automatically inserted here.
+ *       //
+ *       log(" my first module ");
+ *       var version = "1.3";      // this won't pollute global namespace
+ *       exports.version = version;
+ *       exports.logActorPosition = function( actorName )
+ *       {
+ *         var actor = dali.stage.getRootLayer().findChildByName(actorName );
+ *         log( actor.x + "," + actor.y + "," + actor.z );
+ *        }
+ *       //
+ *       // End module code
+ *       //
+ *
+ *       return module.exports;
+ *     }
+
+ *
+ * Initially module.exports is an object literal with name-value pairs ( exports object).
+ * However it can be re-assigned to a constructor / function / singleton object as shown
+ * in the examples above.
+ *
+ *
+ *  ### Circular dependencies:
+ *
+ *  DALi JS supports circular dependencies as required by the CommonJS specification.
+ *
+ *  #### a.js
+ *
+ *
+ *     export.version = "1.3"
+ *     export.loaded = false;
+ *     var bModule = require('b.js')
+ *     export.loaded = true;
+ *
+ *  #### b.js
+ *
+ *     var aModule = require('a.js')
+ *     log( "aModule version = " + aModule.version + ", aModule loaded = " + aModule.loaded );
+ *
+ *     //prints  aModule = 1.3, aModule loaded = false
+ *
+ *  #### main.js
+ *
+ *      var aModule = require("a.js");
+ *
+ *
+ *  When b.js requires a.js, it is given everything that is exported from a.js, up to the point
+ *  b.js is required by a.js.
+ *
+ * ### 'require' background
+ *
+ * There is alternative to module spec in CommonJS called RequireJs ( http://requirejs.org/docs/node.html) 
    
+ * DALi JS tries to follows the CommonJS  specification (used by Node.js) as it
+ * is supposed to be better suited to server side development. 

    
+ *
+ * @method require
+ * @for ModuleLoader
+ *
+ */
+void ModuleLoader::Require(const v8::FunctionCallbackInfo< v8::Value >& args,
+
+                           v8::Persistent& globalObjectTemplate )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  std::string fileName = V8Utils::GetStringParameter( PARAMETER_0, found, isolate , args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "require missing module name");
+    return;
+  }
+
+  // strip off any path / .js
+  std::string moduleName;
+  V8Utils::GetModuleName( fileName, moduleName );
+
+  // see if the module already exists
+  const Module* existingModule = FindModule( moduleName );
+  if( existingModule )
+  {
+    // printf(" using existing module %s \n",moduleName.c_str() );
+    args.GetReturnValue().Set( existingModule->mExportsObject );
+    return;
+  }
+
+  std::string path = mCurrentScriptPath;  // path of top level script being executed
+  std::string contents;
+  V8Utils::GetFileContents(path + fileName, contents);
+
+  // wrap the module in a function to protect global namespace.
+  // the create function itself is global so we make it unique for each module
+  // For reference nodeJs does this as an anonymous function, but we're calling it from native side
+  // so need to pass parameters  / get a name for it.
+  std::string functionName ="__createModule" +  moduleName;
+  std::string source = "function " + functionName + "( exports, module, __filename, __directory)  { ";
+  source+= contents;
+  source+=" \n };";  // close the function
+
+  CompileAndRun( isolate, source, fileName );
+
+  // We need to create module object, so that the module can read / write properties to it
+
+  v8::Local moduleObject = v8::Object::New( isolate );
+  v8::Local exportsObject = v8::Object::New( isolate );
+  moduleObject->Set( v8::String::NewFromUtf8( isolate, "exports"),  exportsObject );
+  moduleObject->Set( v8::String::NewFromUtf8( isolate, "id"), v8::String::NewFromUtf8( isolate ,moduleName.c_str() ) );
+
+  // store the module exports object now, this is to allow for circular dependencies.
+  // If this-module requires another module, which then requires this module ( creating a circle), it will be given an export object
+  // which contains everything exported so far.
+  Module* module = StoreModule( path, fileName, moduleName, isolate, exportsObject );
+
+  v8::Local currentContext =  isolate->GetCurrentContext();
+
+  // get the CreateModule function
+  v8::Local createModule = v8::Local::Cast(currentContext->Global()->Get(v8::String::NewFromUtf8( isolate, functionName.c_str() )));
+
+  // add the arguments
+  std::vector< v8::Local > arguments;
+  arguments.push_back( exportsObject );
+  arguments.push_back( moduleObject );
+  arguments.push_back( v8::String::NewFromUtf8( isolate, fileName.c_str() ));
+  arguments.push_back( v8::String::NewFromUtf8( isolate, path.c_str() ));
+
+
+  // call the CreateModule function
+  createModule->Call( createModule, arguments.size(), &arguments[0]); //[0]
+
+  // get the module.export object, the module writer may have re-assinged module.exports, so the exports object
+  // no longer references it.
+  v8::Local moduleExportsValue = moduleObject->Get( v8::String::NewFromUtf8( isolate, "exports"));
+  v8::Local  moduleExports = moduleExportsValue->ToObject();
+
+  // Re-store the export ( possible nothing happens, because exports hasn't been re-assigned).
+  module->mExportsObject.Reset( isolate, moduleExports);
+
+  args.GetReturnValue().Set( moduleExports );
+
+}
+void ModuleLoader::StoreScriptInfo( const std::string& sourceFileName )
+{
+  V8Utils::GetFileDirectory( sourceFileName, mCurrentScriptPath);
+}
+
+Module* ModuleLoader::StoreModule( const std::string& path,
+                                const std::string& fileName,
+                                const std::string& moduleName,
+
+                                v8::Isolate* isolate,
+                                v8::Local& moduleExportsObject )
+{
+  Module* module = new Module( path, fileName, moduleName, isolate, moduleExportsObject );
+  mModules.PushBack( module );
+  return module;
+
+}
+
+const Module* ModuleLoader::FindModule( const std::string& moduleName )
+{
+  VectorBase::SizeType count =  mModules.Count();
+  for( VectorBase::SizeType  i = 0; i < count ; ++i)
+  {
+    const Module* module = mModules[i];
+    if (module->mModuleName == moduleName )
+    {
+      return module;
+    }
+  }
+  return NULL;
+}
+
+
+} // V8Plugin
+
+} // Dali
diff --git a/plugins/dali-script-v8/src/module-loader/module-loader.h b/plugins/dali-script-v8/src/module-loader/module-loader.h
new file mode 100644
index 0000000..00f3625
--- /dev/null
+++ b/plugins/dali-script-v8/src/module-loader/module-loader.h
@@ -0,0 +1,146 @@
+#ifndef __DALI_V8PLUGIN_MODULE_LOADER_H__
+#define __DALI_V8PLUGIN_MODULE_LOADER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ *
+ * Responsible for executing JavaScript source code.
+ * This includes loading other JavaScript files that may be referenced
+ * inside JavaScript using the 'require' keyword.
+ *
+ * Notes:
+ *
+ * A module named with a forward slash is loaded as an absolute path:
+ * E.g. require "/usr/apps/scripts/my_module.js"
+ *
+ * A module pre-fixed with a dot slash ( current directory) then the path is relative
+ * to the calling scripts path. E.g.
+ *
+ * -- my_first.js --
+ * require "./circle.js";   // load circle.js from same directory as my_first.js
+ *
+ * @TODO
+ * ----------
+ * Without a leading '/' or './' the module is loaded from the DALi modules directory or
+ * the applications user defined module directory.
+ * E.g. require "dali-spline.js"    // search dali-module directory first, then any user
+ * defined module locations.
+ * ------------
+ *
+ *
+ */
+class ModuleLoader
+{
+public:
+
+  /**
+   * Constructor
+   */
+  ModuleLoader();
+
+  /**
+   * non virtual destructor, not intended as a base class
+   */
+  ~ModuleLoader();
+
+
+  /**
+   * Execute a script from a file
+   * @param[in] fileName file name
+   */
+  bool ExecuteScriptFromFile( v8::Isolate* isolate, const std::string& fileName );
+
+
+  /**
+   * Execute a script
+   * @param[in] sourceCode source code to run
+   * @param[in] sourceFileName source file name
+   */
+  bool ExecuteScript( v8::Isolate* isolate,
+                      const std::string& sourceCode,
+                      const std::string& sourceFileName );
+
+
+  /**
+   * Implements JavaScript Require functionality
+   */
+  void Require(const v8::FunctionCallbackInfo< v8::Value >& args, v8::Persistent& globalObjectTemplate );
+
+private:
+
+  /**
+   * Compile and run the JavaScript code
+   * @param[in] sourceCode source code to run
+   * @param[in] sourceFileName source file name
+   */
+  bool CompileAndRun(v8::Isolate* isolate,
+                     const std::string& sourceCode,
+                     const std::string& sourceFileName );
+
+  /**
+   * Store information about the current script
+   * @param[in] sourceFileName source file name
+   */
+  void StoreScriptInfo( const std::string& sourceFileName );
+
+  /**
+   * Store module information
+   * @param[in] sourceFileName source file name
+   * @return module object
+   */
+  Module* StoreModule( const std::string& path,
+                    const std::string& fileName,
+                    const std::string& moduleName,
+                    v8::Isolate* isolate,
+                    v8::Local& moduleExportsObject );
+
+  /**
+   * Find a module
+   * @param[in] moduleName module name
+   * @return module
+   */
+  const Module* FindModule( const std::string& moduleName );
+
+private:
+
+  Dali::Vector< Module*> mModules; ///< vector of modules
+  std::string mCurrentScriptPath;  ///< path of the current script being executed (via ExecuteScript).
+
+};
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header MODULE_LOADER
diff --git a/plugins/dali-script-v8/src/module-loader/module.cpp b/plugins/dali-script-v8/src/module-loader/module.cpp
new file mode 100644
index 0000000..1e095ee
--- /dev/null
+++ b/plugins/dali-script-v8/src/module-loader/module.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "module.h"
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+Module::Module()
+{
+
+}
+
+Module::Module( const std::string& path,
+              const std::string& fileName,
+              const std::string& moduleName,
+
+              v8::Isolate* isolate,
+              v8::Local& exportsObject)
+:mFileName( fileName ),
+ mPath( path),
+ mModuleName(moduleName)
+
+{
+  mExportsObject.Reset( isolate, exportsObject);
+}
+
+Module::~Module()
+{
+
+}
+
+
+
+} // V8Plugin
+
+} // Dali
diff --git a/plugins/dali-script-v8/src/module-loader/module.h b/plugins/dali-script-v8/src/module-loader/module.h
new file mode 100644
index 0000000..e0286bf
--- /dev/null
+++ b/plugins/dali-script-v8/src/module-loader/module.h
@@ -0,0 +1,85 @@
+#ifndef __DALI_V8PLUGIN_MODULE_H__
+#define __DALI_V8PLUGIN_MODULE_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ *
+ * Module class,
+ * contains
+ *
+ */
+class Module
+{
+public:
+
+    Module(const std::string& path,
+          const std::string& fileName,
+          const std::string& moduleName,
+
+        v8::Isolate* isolate,
+        v8::Local& exportsObject);
+
+    ~Module();
+
+    std::string mFileName;
+    std::string mPath;
+    std::string mModuleName;
+
+
+    /**
+     *  holds the exports object
+     *  e.g.  exports.hello = function() {" hello world"}
+     */
+    v8::Persistent mExportsObject;
+
+    /*
+     * Currently we allow the modules context to be released after it has been
+     * compiled and run ( so we don't need to store it).
+     * Data is shared between contexts which suggests
+     * the module exports object can be kept alive if the context it was created in is deleted.
+     * If this is not the case, then start to store the context.
+     */
+    // v8::Persistent mContext.
+
+private:
+
+    Module();
+
+    Module( const Module& );            ///< undefined copy constructor
+    Module& operator=( const Module& ); ///< undefined assignment operator
+
+
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header MODULE_LOADER
diff --git a/plugins/dali-script-v8/src/object/handle-wrapper.cpp b/plugins/dali-script-v8/src/object/handle-wrapper.cpp
new file mode 100644
index 0000000..88a6e3e
--- /dev/null
+++ b/plugins/dali-script-v8/src/object/handle-wrapper.cpp
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "handle-wrapper.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+HandleWrapper::HandleWrapper( BaseWrappedObject::Type type,
+    Handle handle,
+    GarbageCollectorInterface& gc ) :
+ BaseWrappedObject( type, gc ),
+ mHandle( handle )
+{
+}
+
+HandleWrapper::~HandleWrapper()
+{
+
+}
+HandleWrapper*  HandleWrapper::Unwrap( v8::Isolate* isolate, v8::Handle< v8::Object> obj)
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local field = v8::Local::Cast( obj->GetInternalField(0) );
+  void* ptr = field->Value();
+  return static_cast< HandleWrapper *>(ptr);
+}
+
+// may have to do this IsUpper to intercept function calls or as function?
+void HandleWrapper::PropertyGet( v8::Local propertyName,
+                                        const v8::PropertyCallbackInfo& info)
+{
+  v8::Isolate* isolate = info.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  // get the property name
+  std::string name = V8Utils::v8StringToStdString( propertyName );
+
+  if( std::isupper( name[0] ))
+  {
+    return;
+  }
+
+  // unwrap the object
+  HandleWrapper* handleWrapper = Unwrap( isolate, info.This() );
+  Handle handle =  handleWrapper->mHandle;
+
+  // get the property index
+  // convert from camel case to dali property style with hyphens
+  std::string daliPropertyName = V8Utils::JavaScriptNameToPropertyName(name);
+  Dali::Property::Index index = handle.GetPropertyIndex( daliPropertyName );
+
+  if(index != Dali::Property::INVALID_INDEX)
+  {
+    Dali::Property::Value value = handle.GetProperty(index);
+
+    // Simple Dali properties (ints, strings, bools etc) are stored as JavaScript primitives (v8::Boolean ...)
+    // more complex properties (Vectors, Rectangles...) are wrapped by a JavaScript object
+    v8::Local ret = PropertyValueWrapper::WrapDaliProperty( isolate, value );
+
+    info.GetReturnValue().Set( ret );
+  }
+  else
+  {
+    //  std::string error="Invalid property Get for "+name + "\n";
+    // DALI_SCRIPT_EXCEPTION( isolate, error );
+  }
+
+}
+void HandleWrapper::PropertySet( v8::Local propertyName,
+                  v8::Local javaScriptValue,
+                  const v8::PropertyCallbackInfo& info)
+{
+
+  v8::Isolate* isolate = info.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  // get the property name
+  std::string name = V8Utils::v8StringToStdString( propertyName );
+
+  // try to filter out function calls before going to the property system
+  // @todo use installed functions to generate a map
+  if( ( name.compare(0,2,"is") == 0 )  ||
+      ( name.compare(0,3,"get") == 0 ) ||
+      ( name.compare(0,3,"add") == 0 ) ||
+      ( name.compare(0,3,"set") == 0 ) ||
+      ( name.compare(0,3,"get") == 0 ) ||
+      ( name.compare(0,4,"find") == 0 ) ||
+      ( name.compare(0,6,"remove") == 0 )
+     )
+  {
+    //
+    return;
+  }
+  // unwrap the object
+  HandleWrapper* handleWrapper = Unwrap( isolate, info.This() );
+  if( !handleWrapper )
+  {
+    // printf("setting property name %s \n", name.c_str());
+    return;
+  }
+
+ // DALI_ASSERT_DEBUG( handleWrapper && "not a dali object");
+  Handle handle =  handleWrapper->mHandle;
+
+  // convert from camel case to dali property style with hyphens
+  std::string daliPropertyName = V8Utils::JavaScriptNameToPropertyName(name);
+  Dali::Property::Index index = handle.GetPropertyIndex( daliPropertyName );
+
+  if(index != Dali::Property::INVALID_INDEX)
+  {
+    Dali::Property::Type type = handle.GetPropertyType(index);
+
+    // we know the type we want to set ( int, vector, etc..)
+    // try and convert the javascript value in to the type we want.
+    Dali::Property::Value value = PropertyValueWrapper::ExtractPropertyValue( isolate, javaScriptValue, type);
+
+    if( Dali::Property::NONE == value.GetType() )
+      {
+        std::stringstream msg;
+        msg << "Invalid property Set: '";
+        msg << name;
+        msg << "(Index = ";
+        msg << index;
+        msg << ")";
+        msg << "' Cannot convert value to correct type: (";
+        msg << type;
+        msg << ")";
+        msg << Dali::PropertyTypes::GetName(type);
+        DALI_SCRIPT_EXCEPTION( isolate, msg.str().c_str());
+      }
+      else
+      {
+        handle.SetProperty( index, value );
+      }
+  }
+  else
+  {
+    std::string error="Invalid property Set for "+name + "\n";
+    DALI_SCRIPT_EXCEPTION( isolate, error );
+  }
+}
+
+void HandleWrapper::AddInterceptsToTemplate( v8::Isolate* isolate, v8::Local& objTemplate )
+{
+  v8::HandleScope handleScope( isolate );
+
+  objTemplate->SetNamedPropertyHandler( HandleWrapper::PropertyGet, HandleWrapper::PropertySet);
+
+  ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
+
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/object/handle-wrapper.h b/plugins/dali-script-v8/src/object/handle-wrapper.h
new file mode 100644
index 0000000..e0b1859
--- /dev/null
+++ b/plugins/dali-script-v8/src/object/handle-wrapper.h
@@ -0,0 +1,96 @@
+#ifndef __DALI_V8PLUGIN_HANDLE_WRAPPER_H__
+#define __DALI_V8PLUGIN_HANDLE_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+class BaseCallBack;
+
+class HandleWrapper : public BaseWrappedObject
+{
+public:
+  HandleWrapper( BaseWrappedObject::Type type,
+                Handle handle,
+                GarbageCollectorInterface& gc );
+
+  virtual ~HandleWrapper();
+
+  /**
+   * @brief get the value for a property for JavaScript object than contains a Dali Handle.
+   * E.g. Get( "x", JavaScript object that wraps a Dali Handle )
+   * @param[in] propertyName property name
+   * @param[in] info reference to PropertyCallbackInfo structure (contains the Javascript
+   * object and the return value).
+   */
+  static void PropertyGet( v8::Local propertyName,
+                                          const v8::PropertyCallbackInfo& info);
+
+  /**
+   * @brief Set the value for a property for JavaScript object than contains a Dali Handle.
+   * E.g. Set( "x", 103, JavaScript object that wraps a Dali Handle)
+   * @param[in] propertyName property name
+   * @param[in] javaScriptValue javascript value to set, this is typically a number
+   * @param[in] info reference to PropertyCallbackInfo structure (contains the Javascript
+   * object).
+   */
+  static void PropertySet( v8::Local propertyName,
+                    v8::Local javaScriptValue,
+                    const v8::PropertyCallbackInfo& info);
+
+  static HandleWrapper* Unwrap( v8::Isolate* isolate, v8::Handle< v8::Object> obj);
+
+  /**
+   * Should be called by an class that inherits from HandleWrapper to add
+   * property get / set functionality to the javascript object
+   * along with Signal connect / disconnect
+   */
+  static void AddInterceptsToTemplate( v8::Isolate* isolate, v8::Local& objTemplate );
+
+
+  Handle GetHandle() { return mHandle; }
+  Handle mHandle;
+  ConnectionTracker mConnectionTracker;
+
+
+  virtual SignalManager* GetSignalManager() { return &mSignalManager;}
+
+private:
+
+  SignalManager mSignalManager;
+
+};
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/object/property-value-wrapper.cpp b/plugins/dali-script-v8/src/object/property-value-wrapper.cpp
new file mode 100644
index 0000000..5dccbee
--- /dev/null
+++ b/plugins/dali-script-v8/src/object/property-value-wrapper.cpp
@@ -0,0 +1,958 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+// CLASS HEADER
+#include "property-value-wrapper.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+
+struct WrapTypeInfo
+{
+  Dali::Property::Type propertyType;
+  BaseWrappedObject::Type wrappedType;
+};
+/**
+ * lookup table to convert between dali property types and wrapped types
+ * Wrapped types includes actors / timers / render tasks, hence we can't just
+ * use the dali property types to encode what a wrapped pointer contains
+ */
+const WrapTypeInfo WrapTypeInfoLookup[]=
+{
+  { Dali::Property::VECTOR2,    BaseWrappedObject::VECTOR2 },
+  { Dali::Property::VECTOR3,    BaseWrappedObject::VECTOR3 },
+  { Dali::Property::VECTOR4,    BaseWrappedObject::VECTOR4 },
+  { Dali::Property::RECTANGLE,  BaseWrappedObject::RECTANGLE  },
+  { Dali::Property::ROTATION,   BaseWrappedObject::ROTATION   },
+  { Dali::Property::MATRIX,     BaseWrappedObject::MATRIX     },
+  { Dali::Property::MATRIX3,    BaseWrappedObject::MATRIX3    },
+
+
+};
+const unsigned int WrapTypeLookupCount = sizeof( WrapTypeInfoLookup ) / sizeof( WrapTypeInfo );
+
+BaseWrappedObject::Type GetWrappedType( Dali::Property::Type type )
+{
+  for( unsigned int i = 0; i < WrapTypeLookupCount; ++i)
+  {
+    if( WrapTypeInfoLookup[ i ].propertyType == type )
+    {
+      return WrapTypeInfoLookup[ i ].wrappedType;
+    }
+  }
+  DALI_LOG_ERROR("GetWrappedType failed \n");
+  return BaseWrappedObject::UNKNOWN;
+}
+
+// Templates for setting members on propertys, like, x,y,z on a vector
+template 
+void SetX( Dali::Property::Value &value, S& v)
+{
+  // to set a property value, we need to read into a temporary
+  // then assign it back.
+  // E.g.   Vector2 temp = value.Get();
+  //        temp.x = 10;
+  //        value = temp;
+  T tmp( value.Get() );
+  tmp.x = v;
+  value = tmp;
+}
+
+template 
+void SetY( Dali::Property::Value &value, S& v)
+{
+  T tmp = value.Get();
+  tmp.y = v;
+  value = tmp ;
+}
+
+template 
+void SetZ( Dali::Property::Value &value, S& v)
+{
+  T tmp = value.Get();
+  tmp.z = v;
+  value = tmp ;
+}
+
+template 
+void SetW( Dali::Property::Value &value, S& v)
+{
+  T tmp = value.Get();
+  tmp.w = v;
+  value = tmp ;
+}
+template 
+void SetWidth( Dali::Property::Value &value, S& v)
+{
+  T tmp = value.Get();
+  tmp.width = v;
+  value = tmp ;
+}
+
+template 
+void SetHeight( Dali::Property::Value &value, S& v)
+{
+  T tmp = value.Get();
+  tmp.height = v;
+  value = tmp ;
+}
+
+v8::Handle< v8::Value > GetV8ValueFrom( v8::Isolate* isolate,
+                                        const Dali::Property::Value& value,
+                                        const std::string& field)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local ret;
+
+  Dali::Property::Type type = value.GetType();
+  std::string objectType="Unknown type";
+
+  // simple property values are handled by the actor wrapper so we just handle property values with sub fields
+  switch(type)
+  {
+    case Dali::Property::VECTOR2:
+    {
+      objectType = "Vector2";
+
+      if( field == "x" || field == "width" )
+      {
+        Dali::Vector2 v2 = value.Get() ;
+        ret = v8::Number::New( isolate, v2.x) ;
+      }
+      else if(field == "y" || field == "height")
+      {
+        Dali::Vector2 v2 = value.Get() ;
+        ret = v8::Number::New( isolate, v2.y) ;
+      }
+
+      break;
+    }
+    case Dali::Property::VECTOR3:
+    {
+      objectType = "Vector3";
+
+      if(field == "x" || field == "width" || field == "r")
+      {
+        Dali::Vector3 v3 = value.Get() ;
+        ret = v8::Number::New( isolate, v3.x) ;
+      }
+      else if(field == "y" || field == "height" || field == "g")
+      {
+        Dali::Vector3 v3 = value.Get() ;
+        ret = v8::Number::New( isolate, v3.y) ;
+      }
+      else if(field == "z" || field == "depth" || field == "b")
+      {
+        Dali::Vector3 v3 = value.Get() ;
+        ret = v8::Number::New( isolate, v3.z) ;
+      }
+      break;
+    }
+    case Dali::Property::VECTOR4:
+    {
+      objectType = "vector4";
+
+      if(field == "x" || field == "s" || field == "r")
+      {
+        Dali::Vector4 v4 = value.Get() ;
+        ret = v8::Number::New( isolate, v4.x) ;
+      }
+      else if(field == "y" || field == "g" || field == "t")
+      {
+        Dali::Vector4 v4 = value.Get() ;
+        ret = v8::Number::New( isolate, v4.y) ;
+      }
+      else if(field == "z" || field == "r" || field == "b")
+      {
+        Dali::Vector4 v4 = value.Get() ;
+        ret = v8::Number::New( isolate, v4.z) ;
+      }
+      else if(field == "w" || field == "a" || field == "q")
+      {
+        Dali::Vector4 v4 = value.Get() ;
+        ret = v8::Number::New( isolate, v4.w) ;
+      }
+
+      break;
+    }
+    case Dali::Property::ROTATION:
+    {
+      objectType = "rotation";
+
+      if(field == "roll")
+      {
+        Dali::Vector4 v4 = value.Get().EulerAngles();
+        ret = v8::Number::New( isolate, v4.z) ;
+      }
+      else if(field == "pitch")
+      {
+        Dali::Vector4 v4 = value.Get().EulerAngles();
+        ret = v8::Number::New( isolate, v4.x) ;
+      }
+      else if(field == "yaw")
+      {
+        Dali::Vector4 v4 = value.Get().EulerAngles();
+        ret = v8::Number::New( isolate, v4.y) ;
+      }
+
+       else if(field == "axis")
+      {
+        Dali::Vector3 axis;
+        float angle;
+        value.Get().ToAxisAngle(axis, angle);
+        ret = PropertyValueWrapper::WrapDaliProperty( isolate , Dali::Property::Value( axis ) );
+      }
+      else if(field == "angle")
+      {
+        Dali::Vector3 axis;
+        float angle;
+        value.Get().ToAxisAngle(axis, angle);
+        ret = PropertyValueWrapper::WrapDaliProperty( isolate , Dali::Property::Value( angle ) );
+      }
+      break;
+    }
+    case Dali::Property::RECTANGLE:
+    {
+      objectType = "rectangle";
+
+      if(field == "x")
+      {
+        Dali::Rect r = value.Get >() ;
+        ret = v8::Number::New( isolate, r.x) ;
+      }
+      else if(field == "y")
+      {
+        Dali::Rect r = value.Get >() ;
+        ret = v8::Number::New( isolate, r.y) ;
+      }
+      else if(field == "width")
+      {
+        Dali::Rect r = value.Get >() ;
+        ret = v8::Number::New( isolate, r.width) ;
+      }
+      else if(field == "height")
+      {
+        Dali::Rect r = value.Get >() ;
+        ret = v8::Number::New( isolate, r.height) ;
+      }
+      break;
+    }
+
+    default:
+    {
+      // will trigger a type error as ret.IsEmpty() == true
+      break;
+    }
+
+  } // switch type
+
+  if ( ret.IsEmpty() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Cannot get property with field " + objectType+ ":" + field );
+  }
+  return handleScope.Escape(ret);
+}
+
+
+/*
+ * Setting a field on a property,  e.g.  Position.x = 5 or Rect.Width = 100
+ * The only property field that supports a struct is  rotation.axis
+ */
+void SetFromV8Value(v8::Isolate* isolate,
+                     Dali::Property::Value& value,
+                     const std::string& field,
+                     v8::Local v8Value )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  Dali::Property::Type type = value.GetType();
+
+  float asFloat = 0.f;
+  int asInt = 0;
+
+  // all are numbers at the moment
+  if( v8Value->IsNumber() )
+  {
+    asFloat = static_cast(v8Value->NumberValue());
+    asInt   = static_cast(asFloat);
+  }
+  else
+  {
+    // if the v8 value isn't a number, then then only Dali object we support is a Vector3 part of a rotation
+    if( ! (type == Dali::Property::ROTATION && field == "axis") )
+    {
+      DALI_SCRIPT_EXCEPTION(isolate,std::string("Cannot set property with field (value is not a number):") + field);
+      return;
+    }
+  }
+
+  // simple property values are handled by the actor wrapper so we just handle property values with sub fields
+  switch(type)
+  {
+    case Dali::Property::VECTOR2:
+    {
+      if(field == "x" || field == "width")
+      {
+        SetX(value, asFloat) ;
+      }
+      else if(field == "y" || field == "height")
+      {
+        SetY(value, asFloat) ;
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, std::string("Cannot set property with field (unknown type):") + field);
+        return;
+      }
+      break;
+    }
+    case Dali::Property::VECTOR3:
+    {
+      if(field == "x" || field == "width" || field == "r")
+      {
+        SetX(value, asFloat) ;
+      }
+      else if(field == "y" || field == "height" || field == "g")
+      {
+        SetY(value, asFloat) ;
+      }
+      else if(field == "z" || field == "depth" || field == "b")
+      {
+        SetZ(value, asFloat) ;
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, std::string("Cannot set property with field (unknown type):") + field);
+        return;
+      }
+      break;
+    }
+    case Dali::Property::VECTOR4:
+    {
+      if(field == "x" || field == "s" || field == "r")
+      {
+        SetX(value, asFloat) ;
+      }
+      else if(field == "y" || field == "g" || field == "t")
+      {
+        SetY(value, asFloat) ;
+      }
+      else if(field == "z" || field == "r" || field == "b")
+      {
+        SetZ(value, asFloat) ;
+      }
+      else if(field == "w" || field == "a" || field == "q")
+      {
+        SetW(value, asFloat) ;
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION( isolate, std::string("Cannot set property with field (unknown type):") + field);
+        return;
+      }
+      break;
+    }
+    case Dali::Property::ROTATION:
+    {
+      if(field == "roll")
+      {
+        Dali::Vector4 v4 = value.Get().EulerAngles();
+        v4.z = asFloat;
+        value = Dali::Quaternion(v4.x, v4.y, v4.z);
+      }
+      else if(field == "pitch")
+      {
+        Dali::Vector4 v4 = value.Get().EulerAngles();
+        v4.x = asFloat;
+        value = Dali::Quaternion(v4.x, v4.y, v4.z);
+      }
+      else if(field == "yaw")
+      {
+        Dali::Vector4 v4 = value.Get().EulerAngles();
+        v4.y = asFloat;
+        value = Dali::Quaternion(v4.x, v4.y, v4.z);
+      }
+      else if(field == "axis")
+      {
+        Dali::Vector3 axis;
+        float angle;
+        value.Get().ToAxisAngle(axis, angle);
+
+        if( v8Value->IsObject() )
+        {
+          v8::Local object = v8::Local::Cast( v8Value );
+
+          PropertyValueWrapper* wrapper = PropertyValueWrapper::Unwrap( isolate, object );
+          Dali::Property::Value v3 = wrapper->GetValue();
+
+          if(v3.GetType() == Dali::Property::VECTOR3)
+          {
+            value = Dali::Quaternion(angle, v3.Get());
+          }
+          else
+          {
+            DALI_SCRIPT_EXCEPTION( isolate, "Axis expects a Vector3:");
+            return;
+          }
+
+        }
+      }
+      else if(field == "angle")
+      {
+        Dali::Vector3 axis;
+        float angle;
+        value.Get().ToAxisAngle(axis, angle);
+        value = Dali::Quaternion(asFloat, axis);
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(  isolate, std::string("Cannot set property with field (unknown type):") + field);
+        return;
+      }
+      break;
+    }
+    case Dali::Property::RECTANGLE:
+    {
+      if(field == "x")
+      {
+        SetX >(value, asInt) ;
+      }
+      else if(field == "y")
+      {
+        SetY >(value, asInt) ;
+      }
+      else if(field == "width")
+      {
+        SetWidth >(value, asInt) ;
+      }
+      else if(field == "height")
+      {
+        SetHeight >(value, asInt);
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION( isolate, std::string("Cannot set property with field (unknown type):") + field);
+        return;
+      }
+      break;
+    }
+    default:
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, std::string("Cannot set property with field (unknown type):") + field);
+      return;
+      break;
+    }
+
+  } // switch type
+
+} // SetFromV8Value
+
+
+bool IsPrimitive( const Dali::Property::Value &value )
+{
+  switch( value.GetType() )
+  {
+    case Dali::Property::BOOLEAN:
+    case Dali::Property::INTEGER:
+    case Dali::Property::UNSIGNED_INTEGER:
+    case Dali::Property::STRING:
+    case Dali::Property::FLOAT:
+    {
+      return true;
+    }
+    default:
+    {
+      return false;
+    }
+  }
+}
+v8::Local CreateJavaScriptPrimitive( v8::Isolate* isolate, const Dali::Property::Value &value )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local v8Value ;
+
+  switch( value.GetType() )
+   {
+     case Dali::Property::FLOAT:
+     {
+       v8Value = v8::Number::New( isolate, value.Get()  );
+       break;
+     }
+     case Dali::Property::BOOLEAN:
+     {
+       v8Value = v8::Boolean::New(  isolate, value.Get());
+       break;
+     }
+     case Dali::Property::INTEGER:
+     {
+       v8Value = v8::Integer::New( isolate, value.Get());
+       break;
+     }
+     case Dali::Property::UNSIGNED_INTEGER:
+     {
+       v8Value = v8::Integer::New( isolate, value.Get());
+       break;
+     }
+     case Dali::Property::STRING:
+     {
+       std::string string = value.Get< std::string >();
+       v8Value = v8::String::NewFromUtf8( isolate,  string.c_str());
+       break;
+     }
+     default:
+     {
+       DALI_LOG_ERROR("Primitive mismatch \n");
+       break;
+     }
+   }
+ v8::Local ret = v8Value->ToObject();
+
+ return handleScope.Escape( ret );
+}
+
+
+} // un-named namespace
+
+
+
+Dali::Property::Value PropertyValueWrapper::VectorOrMatrixFromV8Array( v8::Isolate* isolate, const v8::Local& v8Value)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  Dali::Property::Value ret;
+
+  if( !v8Value->IsArray() )
+  {
+    return ret;
+  }
+  v8::Local array = v8::Local::Cast( v8Value );//v8::Array::Cast(  *v8Value);
+  uint32_t len = array->Length();
+  float out[16] = {0.f, 0.f, 0.f, 0.f,0.f, 0.f, 0.f, 0.f,0.f, 0.f, 0.f, 0.f,0.f, 0.f, 0.f, 0.f};
+  const unsigned int size = sizeof(out) / sizeof(float);
+  for( uint32_t i=0; i < (len > size? size:len); ++i)
+  {
+    v8::Handle entry = array->Get( i);// v8::Integer::New( isolate, i));
+    if( V8Utils::IsNumberPrimitiveOrObject( entry ) )
+    {
+      out[i] = V8Utils::GetNumberValue( isolate, entry );
+      //printf("entry is a number %d , entry is a int %f \n",(int)i , out[i]  );
+    }
+  }
+  if(16 == len )
+  {
+    ret = Dali::Matrix( out[0] );
+  }
+  else if ( 9 == len )
+  {
+    ret = Dali::Matrix3( out[0],out[1],out[2],out[3],out[4],out[5],out[6],out[7],out[8] );
+  }
+  else if(4 == len)
+  {
+    ret = Dali::Vector4(out[0], out[1], out[2], out[3]);
+  }
+  else if(3 == len)
+  {
+    ret = Dali::Vector3(out[0], out[1], out[2]);
+  }
+  else if(2 == len)
+  {
+    ret = Dali::Vector2(out[0], out[1]);
+  }
+  else if(1 == len)
+  {
+    ret = out[0];
+  }
+
+  return ret;
+}
+
+Dali::Property::Value PropertyValueWrapper::ArrayFromV8Array( v8::Isolate* isolate, const v8::Local& v8Value)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  if( !v8Value->IsArray() )
+  {
+    return Dali::Property::Value();
+  }
+
+  //Cast v8::Value to v8::Array
+  v8::Local v8Array = v8::Local::Cast( v8Value );
+  uint32_t elementCount = v8Array->Length();
+  Dali::Property::Array data( elementCount );
+  bool bFound(false);
+  for( uint32_t i(0); iGet(i) );
+  }
+
+  //return the Property::Value
+  return Dali::Property::Value( data );
+}
+
+v8::Persistent PropertyValueWrapper::mTemplatePrimitive;
+
+
+PropertyValueWrapper::~PropertyValueWrapper()
+{
+
+}
+
+PropertyValueWrapper::PropertyValueWrapper( const Dali::Property::Value& value, GarbageCollectorInterface& gc )
+  : BaseWrappedObject(  GetWrappedType( value.GetType() ), gc ),
+    mValue(value)
+{
+}
+
+Dali::Property::Value PropertyValueWrapper::ExtractPropertyValue( v8::Isolate* isolate, v8::Local< v8::Value> v8Value, Dali::Property::Type type)
+{
+  v8::HandleScope handleScope( isolate);
+
+  Dali::Property::Value daliPropertyValue;
+
+  // check if it's a dali object (vector, rect etc)
+  if( v8Value->IsObject() )
+  {
+    v8::Local object = v8::Handle::Cast(v8Value);
+    if( object->InternalFieldCount() == BaseWrappedObject::FIELD_COUNT )
+    {
+      if( BaseWrappedObject::IsWrappedType( isolate, object, GetWrappedType(type) ) )
+      {
+        PropertyValueWrapper* propertyWrapper = Unwrap( isolate, object );
+        return propertyWrapper->GetValue();
+      }
+    }
+  }
+
+  // check if it's a javascript Array
+  Dali::Property::Value array = VectorOrMatrixFromV8Array( isolate, v8Value );
+
+  switch(type)
+  {
+    case Dali::Property::BOOLEAN:
+    {
+      if( V8Utils::IsBooleanPrimitiveOrObject( v8Value ) )
+      {
+        daliPropertyValue = Dali::Property::Value( V8Utils::GetBooleanValue( isolate, v8Value));
+      }
+      break;
+    }
+    case Dali::Property::FLOAT:
+    {
+      if( V8Utils::IsNumberPrimitiveOrObject( v8Value )  )
+      {
+        daliPropertyValue = Dali::Property::Value( V8Utils::GetNumberValue( isolate, v8Value) );
+      }
+
+      break;
+    }
+    case Dali::Property::INTEGER: // todo is it wise to distinguish int from float in javascript?!
+    {
+      if( v8Value->IsInt32() )
+      {
+        daliPropertyValue = Dali::Property::Value(  v8Value->Int32Value()  ) ;//static_cast( V8Utils::GetNumberValue( isolate, v8Value) ));
+      }
+      break;
+    }
+    case Dali::Property::UNSIGNED_INTEGER:
+    {
+      if( v8Value->IsUint32() )
+      {
+        daliPropertyValue = Dali::Property::Value(  v8Value->Uint32Value() );//static_cast( V8Utils::GetNumberValue( isolate, v8Value) ));
+      }
+      break;
+    }
+    case Dali::Property::STRING:
+    {
+      if( V8Utils::IsStringPrimitiveOrObject( v8Value) )
+      {
+        daliPropertyValue = Dali::Property::Value( V8Utils::GetStringValue( isolate, v8Value) );
+      }
+
+
+      break;
+    }
+    case Dali::Property::VECTOR2:
+    {
+      if( array.GetType() == Dali::Property::VECTOR2 )
+      {
+          daliPropertyValue = array;
+      }
+      break;
+    }
+    case Dali::Property::VECTOR3:
+    {
+      if( array.GetType() == Dali::Property::VECTOR3)
+      {
+        daliPropertyValue = array;
+      }
+      break;
+    }
+    case Dali::Property::VECTOR4:
+    {
+
+      if( array.GetType() == Dali::Property::VECTOR4)
+      {
+        daliPropertyValue = array;
+      }
+      break;
+    }
+    case Dali::Property::ROTATION:
+    {
+      if( array.GetType() == Dali::Property::VECTOR4)
+      {
+        // v4 treated as axis angle
+        Dali::Vector4 v = array.Get();
+        daliPropertyValue = Dali::AngleAxis(Dali::Degree(v[0]), Dali::Vector3(v[1], v[2], v[3]));
+      }
+      else if(array.GetType() == Dali::Property::VECTOR3)
+      {
+        // v3 treated as euler
+        Dali::Vector3 v = array.Get();
+        daliPropertyValue = Dali::Quaternion(v[0], v[1], v[2]);
+      }
+      break;
+    }
+    case Dali::Property::MATRIX:
+    {
+      Dali::Matrix mat = array.Get();
+      daliPropertyValue = mat;
+      break;
+    }
+    case Dali::Property::MATRIX3:
+    {
+      Dali::Matrix3 mat = array.Get();
+      daliPropertyValue = mat;
+      break;
+    }
+    case Dali::Property::ARRAY:
+    {
+      daliPropertyValue = ArrayFromV8Array( isolate, v8Value );
+      break;
+    }
+    case Dali::Property::NONE:
+    case Dali::Property::TYPE_COUNT:
+    default:
+    {
+      break;
+    }
+   } // switch type
+
+   return daliPropertyValue;
+}
+
+void PropertyValueWrapper::NewRotation( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if(!args.IsConstructCall())
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Rotation constructor called without 'new'");
+    return;
+  }
+  v8::Local object;
+
+  float v[4] = {0.f,0.f,0.f,0.f} ;
+
+  bool foundAllArguments(false);
+  V8Utils::ReadFloatArguments( foundAllArguments, v, 4, args, 0.f );
+
+  int len = args.Length();
+
+  // if length = 4 create AngleAxis, else create Quaternion
+
+  if(len > 3)
+  {
+    Dali::AngleAxis axis(  Dali::Degree(v[0] ), Dali::Vector3(v[1], v[2], v[3]) );
+    object = WrapDaliProperty( isolate ,   Dali::Property::Value( axis ) );
+  }
+  else if(len > 2)
+  {
+    Dali::Quaternion quaternion( v[0], v[1], v[2] );
+    object = WrapDaliProperty( isolate ,  Dali::Property::Value( quaternion ) );
+  }
+  else
+  {
+    Dali::Quaternion quaternion( Dali::Quaternion(0.f, Dali::Vector4::YAXIS));
+    object = WrapDaliProperty( isolate , Dali::Property::Value( quaternion ) );
+  }
+
+  args.GetReturnValue().Set( object );
+}
+
+//
+void PropertyValueWrapper::NewMatrix( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if(!args.IsConstructCall())
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Rotation constructor called without 'new'");
+    return;
+  }
+  v8::Local object;
+
+  // we're constructing either a 4x4 Dali::Matrix or a 3x3 Dali::Matrix
+  // we're expecting an array of floats
+  // 4x4 = m00, m01, m02, m03,  m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33
+  // 3x3 or m00, m01, m02, m10, m11, m12,m20, m21, m22, m30, m31, m32,
+  bool foundAllArguments( false );
+
+  if( args.Length() == 16 )
+  {
+    float v[16];
+    V8Utils::ReadFloatArguments( foundAllArguments, v, 16, args, 0.f );
+    if(! foundAllArguments )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid Matrix parameters");
+      return;
+    }
+    Dali::Matrix matrix( v[0] );
+    object = WrapDaliProperty( isolate ,  Dali::Property::Value( matrix ) );
+  }
+  else if ( args.Length() == 9 )
+  {
+    float v[9];
+    V8Utils::ReadFloatArguments( foundAllArguments, v, 9, args, 0.f );
+    if(! foundAllArguments )
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "invalid Matrix parameters");
+      return;
+    }
+    Dali::Matrix3 matrix( v[0], v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8] );
+    object = WrapDaliProperty( isolate ,  Dali::Property::Value( matrix ) );
+  }
+  args.GetReturnValue().Set( object );
+
+
+}
+
+v8::Handle PropertyValueWrapper::MakeDaliPropertyTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // property handle intercepts property getters and setters
+  objTemplate->SetNamedPropertyHandler( PropertyGet, PropertySet);
+
+  return handleScope.Escape( objTemplate );
+
+}
+
+v8::Handle PropertyValueWrapper::WrapDaliProperty(v8::Isolate* isolate, const Dali::Property::Value &value)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  // Simple Dali properties (ints, strings, bools etc) are stored as JavaScript primitives (v8::Boolean ...)
+  // more complex properties (Vectors, Rectangles...) are wrapped by a JavaScript object
+  if( IsPrimitive( value ))
+  {
+    return handleScope.Escape( CreateJavaScriptPrimitive( isolate, value) );
+  }
+
+  // This will wrap a Dali structure (Vector, Rect, Matrix etc) inside a JavaScript object.
+
+  v8::Local objectTemplate;
+
+  if(PropertyValueWrapper::mTemplatePrimitive.IsEmpty() )
+  {
+    objectTemplate = MakeDaliPropertyTemplate( isolate );
+    PropertyValueWrapper::mTemplatePrimitive.Reset( isolate, objectTemplate);
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, PropertyValueWrapper::mTemplatePrimitive );
+  }
+
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  PropertyValueWrapper* pointer =  new PropertyValueWrapper( value, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+   // assign the JavaScript object to the wrapper.
+  // This also stores Dali object, in an internal field inside the JavaScript object.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+
+}
+
+// Utility function that extracts the C++ map pointer from a wrapper
+// object.
+
+PropertyValueWrapper*  PropertyValueWrapper::Unwrap( v8::Isolate* isolate, v8::Handle< v8::Object> obj)
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local field = v8::Local::Cast( obj->GetInternalField(0) );
+  void* ptr = field->Value();
+  return static_cast< PropertyValueWrapper *>(ptr);
+}
+
+void PropertyValueWrapper::PropertyGet( v8::Local propertyName,
+                                        const v8::PropertyCallbackInfo& info)
+{
+  v8::Isolate* isolate = info.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  std::string name = V8Utils::v8StringToStdString( propertyName );
+
+  // unwrap the object
+  PropertyValueWrapper* propWrapper = Unwrap( isolate, info.This() );
+
+  v8::Local value = GetV8ValueFrom( isolate, propWrapper->mValue, name );
+
+  info.GetReturnValue().Set( value );
+}
+
+void PropertyValueWrapper::PropertySet( v8::Local propertyName,
+                  v8::Local javaScriptValue,
+                  const v8::PropertyCallbackInfo& info)
+{
+  v8::Isolate* isolate = info.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  std::string name =  V8Utils::v8StringToStdString( propertyName );
+
+  PropertyValueWrapper* propWrapper = Unwrap( isolate, info.This() );
+
+  SetFromV8Value( isolate, propWrapper->mValue, name, javaScriptValue );
+
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/object/property-value-wrapper.h b/plugins/dali-script-v8/src/object/property-value-wrapper.h
new file mode 100644
index 0000000..8cb2dac
--- /dev/null
+++ b/plugins/dali-script-v8/src/object/property-value-wrapper.h
@@ -0,0 +1,160 @@
+#ifndef __DALI_V8PLUGIN_PROPERTYVALUE_WRAPPER_H__
+#define __DALI_V8PLUGIN_PROPERTYVALUE_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An PropertyValue wrapper.
+ * Provides access to Property Value specific functionality and V8 memory handling.
+ *
+ * Only wraps complex types.
+ * Native JavaScript Property Value types such as float, bool string etc are handled by the actor wrapper.
+ * This supports sub property access for maps and vector.x etc and math functionality not easily mapped
+ * to JavaScript objects.
+ *
+ */
+class PropertyValueWrapper : public BaseWrappedObject
+{
+public:
+
+  /**
+   * @brief Constructor
+   * @param[in] value property value to wrap
+   * @param[in] gc Dali garbage collector interface
+   */
+  explicit PropertyValueWrapper( const Dali::Property::Value& value, GarbageCollectorInterface& gc );
+
+  /**
+   * @brief Destructor
+   */
+  virtual ~PropertyValueWrapper();
+
+  /**
+   * @brief Creates a new Rotation wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted as (x=0,y=0)
+   */
+  static void NewRotation( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * @brief Creates a new Matrix wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments can be a 4 x 4 matrix or a 3 x 3 matrix
+   */
+  static void NewMatrix( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * @brief Wraps a dali property value inside a JavaScript object
+   * @return JavaScript object
+   */
+  static v8::Handle WrapDaliProperty(v8::Isolate* isolate, const Dali::Property::Value &value);
+
+  /**
+   * @brief Extract a property value wrapper from a javascript object
+   * @return property value wrapper
+   */
+  static PropertyValueWrapper*  Unwrap( v8::Isolate* isolate, v8::Handle< v8::Object> obj);
+
+  /**
+   * Extract a property value from a javascript object, of a given type
+   * @return property value
+   */
+  static Dali::Property::Value ExtractPropertyValue( v8::Isolate* isolate, v8::Local< v8::Value> v8Value, Dali::Property::Type type);
+
+  /**
+   * @brief Extract a vector or a matrix from a JavaScript array
+   * @return property value ( vector or matrix)
+   */
+  static Dali::Property::Value VectorOrMatrixFromV8Array( v8::Isolate* isolate, const v8::Local& v8Value);
+
+  /**
+   * @brief Extract a Dali Property::Array from a JavaScript array
+   * @return array property value ( vector or matrix)
+   */
+  static Dali::Property::Value ArrayFromV8Array( v8::Isolate* isolate, const v8::Local& v8Value);
+
+  /**
+   * @return property value
+   */
+   Dali::Property::Value GetValue()
+   {
+     return mValue;
+   }
+
+private:
+
+
+   /**
+    * @brief get the value for a property for JavaScript object than contains a Dali object.
+    * E.g. Get( "x", JavaScript object that wraps a Dali Vector2 )
+    * @param[in] propertyName property name
+    * @param[in] info reference to PropertyCallbackInfo structure (contains the Javascript
+    * object and the return value).
+    */
+   static void PropertyGet( v8::Local propertyName,
+                             const v8::PropertyCallbackInfo& info);
+
+
+   /**
+    * @brief Set the value for a property for JavaScript object than contains a Dali object.
+    * E.g. Set( "x", 103, JavaScript object that wraps a Dali Vector2 )
+    * @param[in] propertyName property name
+    * @param[in] javaScriptValue javascript value to set, this is typically a number
+    * @param[in] info reference to PropertyCallbackInfo structure (contains the Javascript
+    * object).
+    */
+   static void PropertySet( v8::Local propertyName,
+                     v8::Local javaScriptValue,
+                     const v8::PropertyCallbackInfo& info);
+
+
+
+
+  // The Property Value ObjectTemplates
+  static v8::Persistent mTemplatePrimitive;
+
+  /**
+   * @brief used to make Vectors, rotation and rect template
+   * Just produces an object template with 2 internal fields
+   * A type and a pointer to the dali object
+   */
+  static v8::Handle MakeDaliPropertyTemplate( v8::Isolate* isolate );
+
+private:
+
+  Dali::Property::Value mValue;     ///< property value
+};
+
+} // V8Plugin
+
+} // Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-api.cpp b/plugins/dali-script-v8/src/render-tasks/render-task-api.cpp
new file mode 100644
index 0000000..b87c123
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-api.cpp
@@ -0,0 +1,526 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// CLASS HEADER
+#include "render-task-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+
+RenderTask GetRenderTask( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  RenderTaskWrapper* wrapper = static_cast< RenderTaskWrapper *>(ptr);
+  return wrapper->GetRenderTask();
+}
+
+}
+
+/**
+ * Set the actors to be rendered
+ * @method setSourceActor
+ * @for RenderTask
+ * @param {Object} actor This actor and its children will be rendered.
+ */
+void RenderTaskApi::SetSourceActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+  bool found( false );
+  Actor sourceActor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+
+  if( found )
+  {
+    renderTask.SetSourceActor( sourceActor );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "source actor not found" );
+  }
+
+}
+/**
+ * Get the actor to be rendered
+ * @method getSourceActor
+ * @for RenderTask
+ * @param {Object} actor source actor
+ */
+void RenderTaskApi::GetSourceActor(const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  Actor source = renderTask.GetSourceActor();
+
+  v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, source );
+  args.GetReturnValue().Set( wrappedActor );
+}
+
+/**
+ * Set whether the RenderTask has exclusive access to the source actors; the default is false.
+ * @method setExclusive
+ * @for RenderTask
+ * @param {Boolean} exclusive True if the source actors will only be rendered by this render-task.
+ */
+void RenderTaskApi::SetExclusive( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  bool found( false );
+  bool exclusive = V8Utils::GetBooleanParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter missing" );
+    return;
+  }
+  renderTask.SetExclusive( exclusive );
+
+}
+
+/**
+ * Query whether the RenderTask has exclusive access to the source actors.
+ * @method isExclusive
+ * @for RenderTask
+ * @return {Boolean} exclusive True if the source actors will only be rendered by this render-task.
+ */
+void RenderTaskApi::IsExclusive( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, renderTask.IsExclusive() ) );
+
+}
+
+/**
+ * Set whether the render-task should be considered for input handling; the default is true.
+ *
+ * The task used for input handling will be last task in the RenderTaskList which has input enabled,
+ * and has a valid source & camera actor.
+ * A RenderTask targetting a frame-buffer can still be hit-tested, provided that the screen->frame-buffer
+ * coordinate conversion is successful; see also SetScreenToFrameBufferFunction().
+ * @method setInputEnabled
+ * @for RenderTask
+ * @param {Boolean} enabled True if the render-task should be considered for input handling.
+ */
+void RenderTaskApi::SetInputEnabled( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  bool found( false );
+  bool inputEnabled = V8Utils::GetBooleanParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter missing" );
+    return;
+  }
+  renderTask.SetInputEnabled( inputEnabled );
+
+}
+
+/**
+ * Query whether the render-task should be considered for input handling.
+ * @method getInputEnabled
+ * @for RenderTask
+ * @return {Boolean} enabled True if the render-task should be considered for input handling.
+ */
+void RenderTaskApi::GetInputEnabled( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, renderTask.GetInputEnabled() ) );
+
+
+}
+
+/**
+ * Set the actor from which the scene is viewed.
+ * @method setCameraActor
+ * @for RenderTask
+ * @param {Object} cameraActor The scene is viewed from the perspective of this actor.
+ */
+void RenderTaskApi::SetCameraActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+  bool found (false );
+  CameraActor cameraActor;
+  Actor actor =  V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    cameraActor = CameraActor::DownCast( actor );
+  }
+
+  if( cameraActor )
+  {
+     renderTask.SetCameraActor( cameraActor );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "source actor not found" );
+  }
+
+}
+
+/**
+ * Retrieve the actor from which the scene is viewed..
+ * @method getCameraActor
+ * @for RenderTask
+ * @return {Object} cameraActor The scene is viewed from the perspective of this actor.
+ */
+void RenderTaskApi::GetCameraActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  Actor cameraActor = renderTask.GetSourceActor();
+
+  v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, cameraActor );
+  args.GetReturnValue().Set( wrappedActor );
+
+}
+
+/**
+ * Set the frame-buffer used as a render target.
+ * @method setTargetFrameBuffer
+ * @for RenderTask
+ * @param {Object}  frameBuffer A valid frame-buffer handle to enable off-screen rendering, or an uninitialized handle to disable.
+ */
+void RenderTaskApi::SetTargetFrameBuffer(const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  bool found( false );
+  // @TODO Test this, may need to implement a Framebuffer image.?
+  Image image = V8Utils::GetImageParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "bad parameters" );
+     return;
+  }
+
+  FrameBufferImage frameBufferImage = FrameBufferImage::DownCast(image);
+
+  renderTask.SetTargetFrameBuffer( frameBufferImage );
+
+}
+
+
+/**
+ * Get the frame-buffer used as a render target.
+ * @method getTargetFrameBuffer
+ * @for RenderTask
+ * @return {Object}  frameBuffer A valid frame-buffer handle to enable off-screen rendering, or an uninitialized handle to disable.
+ */
+void RenderTaskApi::GetTargetFrameBuffer( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  // wrap the image
+  // @TODO Test this, may need to implement a Framebuffer image wrapper.?
+  v8::Local localObject = ImageWrapper::WrapImage( isolate, renderTask.GetTargetFrameBuffer(),ImageWrapper::FRAME_BUFFER_IMAGE );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+/**
+ * Set the actor used to convert screen coordinates to frame-buffer coordinates.
+ *
+ * The local coordinates of the actor are mapped as frame-buffer coordinates.
+ * This is useful for hit-testing actors which are rendered off-screen.
+ * Note: The mapping actor needs to be rendered by the default render task to make the mapping work properly.
+ * @method setScreenToFrameBufferMappingActor
+ * @for RenderTask
+ * @param {Object}  mappingActor The actor used for conversion.
+ */
+void RenderTaskApi::SetScreenToFrameBufferMappingActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+  bool found( false );
+  Actor sourceActor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+
+  if( found )
+  {
+    renderTask.SetScreenToFrameBufferMappingActor( sourceActor );
+  }
+  else
+  {
+      DALI_SCRIPT_EXCEPTION( isolate, "source actor not found" );
+  }
+}
+
+/**
+ * Retrieve the actor used to convert screen coordinates to frame-buffer coordinates.
+ *
+ * @method getScreenToFrameBufferMappingActor
+ * @for RenderTask
+ * @return {Object} actor used for conversion.
+ */
+void RenderTaskApi::GetScreenToFrameBufferMappingActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  Actor source = renderTask.GetScreenToFrameBufferMappingActor();
+
+  v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, source );
+  args.GetReturnValue().Set( wrappedActor );
+}
+
+/**
+ * Retrieve the GL viewport used when rendering.
+ *
+ * @method getViewport
+ * @for RenderTask
+ * @return {Object} object with the properties { x,y,width,height }
+ */
+void RenderTaskApi::GetViewport( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  v8::Local viewportObject = v8::Object::New( isolate );
+
+  Viewport viewPort = renderTask.GetViewport();
+
+  viewportObject->Set( v8::String::NewFromUtf8( isolate, "x"), v8::Number::New( isolate,viewPort.x ));
+  viewportObject->Set( v8::String::NewFromUtf8( isolate, "y"), v8::Number::New( isolate,viewPort.y ));
+  viewportObject->Set( v8::String::NewFromUtf8( isolate, "width"), v8::Number::New( isolate,viewPort.width ));
+  viewportObject->Set( v8::String::NewFromUtf8( isolate, "height"), v8::Number::New( isolate,viewPort.height ));
+
+  args.GetReturnValue().Set( viewportObject );
+
+}
+
+/**
+ * Set the GL viewport used when rendering.
+ * This specifies the transformation between normalized device coordinates and target window (or frame-buffer) coordinates.
+ * By default this will match the target window or frame-buffer size.
+ * Unlike the glViewport method, the x & y coordinates refer to the top-left of the viewport rectangle.
+ * @method setViewport
+ * @for RenderTask
+ * @param {Object} object with the properties { x,y,width,height }
+ */
+void RenderTaskApi::SetViewport( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  if( args.Length() != 1 )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "missing / invalid parameters" );
+     return;
+  }
+  v8::Local viewportValue = args[0];
+  if( !viewportValue->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "invalid parameters" );
+    return;
+  }
+  v8::Local obj = viewportValue->ToObject();
+  v8::Local xValue = obj->Get( v8::String::NewFromUtf8( isolate, "x" ) );
+  v8::Local yValue = obj->Get( v8::String::NewFromUtf8( isolate, "y" ) );
+  v8::Local widthValue = obj->Get( v8::String::NewFromUtf8( isolate, "width" ) );
+  v8::Local heightValue = obj->Get( v8::String::NewFromUtf8( isolate, "height" ) );
+
+  if( xValue->IsNumber() &&  yValue->IsNumber() &&   widthValue->IsNumber() &&  heightValue->IsNumber())
+  {
+    Viewport viewPort;
+    viewPort.x= xValue->ToNumber()->Value();
+    viewPort.y = yValue->ToNumber()->Value();
+    viewPort.width = widthValue->ToNumber()->Value();
+    viewPort.height = heightValue->ToNumber()->Value();
+    renderTask.SetViewport( viewPort );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing x,y,width,height property" );
+    return;
+  }
+}
+
+/**
+ * Set whether the render-task will clear the results of previous render-tasks.
+ *
+ * The default is false.
+ *
+ * The default GL surface is cleared automatically at the
+ * beginning of each frame; this setting is only useful when 2+
+ * render-tasks are used, and the result of the first task needs to
+ * be (partially) cleared before rendering the second. * @method setViewport
+ * @for RenderTask
+ * @method setClearEnabled
+ * @param {Boolean} enabled True if the render-task should clear
+ */
+void RenderTaskApi::SetClearEnabled( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  bool found( false );
+  bool clearEnabled = V8Utils::GetBooleanParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter missing" );
+    return;
+  }
+  renderTask.SetClearEnabled( clearEnabled );
+
+}
+
+/**
+ * Query whether the render-task will clear the results of previous render-tasks.
+ *
+ * @for RenderTask
+ * @method getClearEnabled
+ * @return {Boolean} True if the render-task should clear.
+ */
+void RenderTaskApi::GetClearEnabled( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, renderTask.GetClearEnabled() ) );
+}
+
+/**
+ * Set whether the render task will cull the actors to the camera's view frustum.
+ * Note that this will only affect image actors that use the default vertex shader.
+ * The default mode is to cull actors.
+ * @for RenderTask
+ * @method setCullMode
+ * @param {Boolean}  cullMode True if the renderers should be culled.
+ */
+void RenderTaskApi::SetCullMode ( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  bool found( false );
+  bool cullMode = V8Utils::GetBooleanParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "boolean parameter missing" );
+    return;
+  }
+  renderTask.SetCullMode( cullMode );
+}
+
+/**
+ * Get the cull mode
+ * @for RenderTask
+ * @method getCullMode
+ * @return {Boolean}  cullMode True if the renderers should be culled.
+ */
+void RenderTaskApi::GetCullMode( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate, renderTask.GetCullMode() ) );
+}
+
+/**
+ * Set the refresh-rate of the RenderTask.
+ *
+ * The default is dali.REFRESH_ALWAYS (1), meaning that the RenderTask will be processed every frame.
+ * It may be desirable to process less frequently e.g. SetRefreshRate(3) will process once every 3 frames.
+ * The dali.REFRESH_ONCE value means that the RenderTask will be processed once only, to take a snap-shot of the scene.
+ * Repeatedly calling setRefreshRate(dali.REFRESH_ONCE) will cause more snap-shots to be taken.
+ * @method setRefreshRate
+ * @param {Integer} refresh rate  (0 =  dali.REFRESH_ONCE, 1= dali.REFRESH_ALWAYS)
+ */
+void RenderTaskApi::SetRefreshRate( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  bool found( false );
+  int rate = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "Integer parameter missing" );
+     return;
+  }
+  renderTask.SetRefreshRate( rate );
+}
+
+/**
+ *  Query the refresh-rate of the RenderTask.
+ * @method getRefreshRate
+ * @return {Integer} refresh rate  (0 =  dali.REFRESH_ONCE, 1= dali.REFRESH_ALWAYS)
+ */
+void RenderTaskApi::GetRefreshRate( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTask renderTask = GetRenderTask( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, renderTask.GetRefreshRate() ) );
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-api.h b/plugins/dali-script-v8/src/render-tasks/render-task-api.h
new file mode 100644
index 0000000..efd7444
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-api.h
@@ -0,0 +1,64 @@
+#ifndef __DALI_V8PLUGIN_RENDER_TASK_API_H__
+#define __DALI_V8PLUGIN_RENDER_TASK_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace RenderTaskApi
+{
+
+
+  /**
+   * RenderTask API see render-task.h for a description
+   */
+  void SetSourceActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetSourceActor(const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetExclusive( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsExclusive( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetInputEnabled( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetInputEnabled( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetCameraActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetCameraActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetTargetFrameBuffer(const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetTargetFrameBuffer( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetScreenToFrameBufferMappingActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetScreenToFrameBufferMappingActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetViewport( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetViewport( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetClearEnabled( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetClearEnabled( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetCullMode ( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetCullMode( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetRefreshRate( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetRefreshRate( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace RenderTaskApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_RENDER_TASK_API_H__
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-list-api.cpp b/plugins/dali-script-v8/src/render-tasks/render-task-list-api.cpp
new file mode 100644
index 0000000..311bedb
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-list-api.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "render-task-list-api.h"
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+/**
+ *
+## RenderTaskList API
+
+
+An ordered list of Dali::RenderTasks
+
+These tasks describe how the Dali scene should be rendered;
+See {{#crossLink "RenderTask"}}{{/crossLink}}
+
+ @class RenderTaskList
+*/
+
+
+RenderTaskList GetRenderTaskList( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField( 0 ) );
+  void* ptr = field->Value();
+
+  RenderTaskListWrapper* wrapper = static_cast( ptr );
+  return wrapper->GetRenderTaskList();
+}
+
+
+} // un-named namespace
+
+/**
+ * Create a new RenderTask.
+ * This will be appended to the list of render-tasks.
+ * @method createTask
+ * @for RenderTaskList
+ * @return {Object} RenderTask
+ */
+void RenderTaskListApi::CreateTask( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTaskList taskList = GetRenderTaskList( isolate, args);
+
+  RenderTask renderTask = taskList.CreateTask();
+
+  v8::Handle wrappedTask = RenderTaskWrapper::WrapRenderTask(isolate, renderTask);
+  args.GetReturnValue().Set( wrappedTask  );
+
+}
+
+/**
+ * Remove a RenderTask from the list of render-tasks.
+ * @method removeTask
+ * @for RenderTaskList
+ * @param{Object} RenderTask to remove
+ */
+void RenderTaskListApi::RemoveTask( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTaskList taskList = GetRenderTaskList( isolate, args );
+
+  bool found( false );
+  RenderTask renderTask = V8Utils::GetRenderTaskParameter( PARAMETER_0, found, isolate, args );
+  if(! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "render-task parameter missing" );
+    return;
+  }
+  taskList.RemoveTask( renderTask );
+}
+/**
+ * Query the number of render-tasks in the list.
+ * This is ordered i.e. the task with index 0 is the first to be processed each frame.
+ * @method getTaskCount
+ * @for RenderTaskList
+ * @return {Number}  The number of render-tasks.
+ */
+void RenderTaskListApi::GetTaskCount( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTaskList taskList = GetRenderTaskList( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, taskList.GetTaskCount() ) );
+
+}
+/**
+ * Retrieve a render-task.
+ * index should be in range i.e. less than GetTaskCount().
+ * @method getTask
+ * @for RenderTaskList
+ * @param {Number} index The index of the render task to retrieve
+ * @return {Object}  The render-task
+ */
+void RenderTaskListApi::GetTask( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  RenderTaskList taskList = GetRenderTaskList( isolate, args );
+
+  bool found( false );
+  int index = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "Integer parameter missing" );
+     return;
+  }
+  RenderTask renderTask = taskList.GetTask( index );
+
+  v8::Handle wrappedTask = RenderTaskWrapper::WrapRenderTask(isolate, renderTask);
+  args.GetReturnValue().Set( wrappedTask  );
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-list-api.h b/plugins/dali-script-v8/src/render-tasks/render-task-list-api.h
new file mode 100644
index 0000000..6472ffa
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-list-api.h
@@ -0,0 +1,53 @@
+#ifndef __DALI_V8PLUGIN_RENDER_TASK_LIST_API_H__
+#define __DALI_V8PLUGIN_RENDER_TASK_LIST_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace RenderTaskListApi
+{
+  /**
+   * Constructor
+   */
+  RenderTaskList New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+
+  /**
+   * RenderTaskList API see render-task-list.h for a description
+   */
+  void CreateTask( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void RemoveTask( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetTaskCount( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetTask( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace RenderTaskListApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_RENDER_TASK_LIST_API_H__
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.cpp b/plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.cpp
new file mode 100644
index 0000000..03e4dfb
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "render-task-list-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+namespace V8Plugin
+{
+
+v8::Persistent RenderTaskListWrapper::mRenderTaskListTemplate;
+
+namespace
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction RenderTaskListFunctionTable[]=
+{
+    /**************************************
+    * RenderTaskList API (in order of renderTaskList.h)
+    **************************************/
+
+    { "CreateTask"             , RenderTaskListApi::CreateTask     },
+    { "RemoveTask"             , RenderTaskListApi::RemoveTask     },
+    { "GetTaskCount"           , RenderTaskListApi::GetTaskCount   },
+    { "GetTask"                , RenderTaskListApi::GetTask        },
+
+
+};
+
+const unsigned int RenderTaskListFunctionTableCount = sizeof(RenderTaskListFunctionTable)/sizeof(RenderTaskListFunctionTable[0]);
+} //un-named space
+
+
+RenderTaskListWrapper::RenderTaskListWrapper( const Dali::RenderTaskList& renderTaskList, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::RENDER_TASK_LIST , gc )
+{
+    mRenderTaskList = renderTaskList;
+}
+
+RenderTaskListWrapper::~RenderTaskListWrapper()
+{
+
+}
+
+v8::Handle RenderTaskListWrapper::WrapRenderTaskList(v8::Isolate* isolate, const Dali::RenderTaskList& renderTaskList )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetRenderTaskListTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the RenderTaskList wrapper
+  RenderTaskListWrapper* pointer =  new RenderTaskListWrapper( renderTaskList, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local RenderTaskListWrapper::GetRenderTaskListTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  if( mRenderTaskListTemplate.IsEmpty() )
+  {
+    objectTemplate = MakeRenderTaskListTemplate( isolate );
+    mRenderTaskListTemplate.Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, mRenderTaskListTemplate );
+  }
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle RenderTaskListWrapper::MakeRenderTaskListTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  // add intercepts for Signals, we can't use HandleWrapper::AddIntercepts because RenderTaskList doesn't inherit
+  // from Handle ( just baseHandle)
+  ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, RenderTaskListFunctionTable, RenderTaskListFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+//  v8::Local localObject = WrapRenderTaskList( isolate, renderTaskList );
+ // args.GetReturnValue().Set( localObject );
+
+
+
+RenderTaskList RenderTaskListWrapper::GetRenderTaskList()
+{
+  return mRenderTaskList;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.h b/plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.h
new file mode 100644
index 0000000..6450665
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-list-wrapper.h
@@ -0,0 +1,75 @@
+#ifndef __DALI_V8PLUGIN_RENDER_TASK_LIST_WRAPPER_H__
+#define __DALI_V8PLUGIN_RENDER_TASK_LIST_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * RenderTaskList  wrapper.
+ * Provides access to RenderTaskList specific functionality
+ */
+class RenderTaskListWrapper : public BaseWrappedObject
+{
+
+public:
+
+  RenderTaskListWrapper( const RenderTaskList& renderTaskList,
+                GarbageCollectorInterface& gc );
+
+  virtual ~RenderTaskListWrapper();
+
+  /**
+   * Wraps an renderTaskList
+   */
+  static v8::Handle WrapRenderTaskList(v8::Isolate* isolate, const Dali::RenderTaskList& );
+
+
+  // The RenderTaskListAttribute ObjectTemplate, we cache templates so we don't have
+  // keep generating them everytime we want to create an RenderTaskList
+  static v8::Persistent mRenderTaskListTemplate;
+
+  RenderTaskList GetRenderTaskList();
+
+
+private:
+
+  RenderTaskList mRenderTaskList;  ///< renderTaskList object
+
+  static v8::Handle MakeRenderTaskListTemplate( v8::Isolate* isolate );
+  static v8::Local GetRenderTaskListTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_RENDER_TASK_LIST_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-wrapper.cpp b/plugins/dali-script-v8/src/render-tasks/render-task-wrapper.cpp
new file mode 100644
index 0000000..6d48d80
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-wrapper.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "render-task-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+v8::Persistent RenderTaskWrapper::mRenderTaskTemplate;
+
+namespace // un-named name space
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction RenderTaskFunctionTable[]=
+{
+    /**************************************
+    * RenderTask API (in order of renderTask.h)
+    **************************************/
+
+   { "SetSourceActor"             , RenderTaskApi::SetSourceActor },
+   { "GetSourceActor"             , RenderTaskApi::GetSourceActor },
+   { "SetExclusive"               , RenderTaskApi::SetExclusive },
+   { "IsExclusive"                , RenderTaskApi::IsExclusive },
+   { "SetInputEnabled"            , RenderTaskApi::SetInputEnabled },
+   { "GetInputEnabled"            , RenderTaskApi::GetInputEnabled },
+   { "SetCameraActor"             , RenderTaskApi::SetCameraActor },
+   { "GetCameraActor"             , RenderTaskApi::GetCameraActor },
+   { "SetTargetFrameBuffer"       , RenderTaskApi::SetTargetFrameBuffer },
+   { "GetTargetFrameBuffer"        , RenderTaskApi::GetTargetFrameBuffer },
+   { "SetScreenToFrameBufferMappingActor" , RenderTaskApi::SetScreenToFrameBufferMappingActor },
+   { "GetScreenToFrameBufferMappingActor" , RenderTaskApi::GetScreenToFrameBufferMappingActor },
+
+   // USE viewportPosition property "SetViewportPosition" , RenderTaskApi::SetViewportPosition },
+   // USE viewportPosition property{ "GetCurrentViewportPosition" , RenderTaskApi::GetCurrentViewportPosition },
+   // USE viewportSize property { "SetViewportSize" ,       RenderTaskApi::SetViewportSize },
+   // USE viewportSize property { "SetViewportSize" ,       RenderTaskApi::SetViewportSize },
+
+   { "GetViewport" ,                RenderTaskApi::GetViewport },
+   { "SetViewport" ,                RenderTaskApi::SetViewport },
+
+   // USE clearColor property, { "SetClearColor" ,        RenderTaskApi::SetClearColor },
+   // USE clearColor property, // { "GetClearColor" ,     RenderTaskApi::GetClearColor },
+
+   { "SetClearEnabled" ,            RenderTaskApi::SetClearEnabled },
+   { "GetClearEnabled" ,            RenderTaskApi::GetClearEnabled },
+   { "SetCullMode" ,                RenderTaskApi::SetCullMode },
+   { "GetCullMode" ,                RenderTaskApi::GetCullMode },
+   { "SetRefreshRate" ,             RenderTaskApi::SetRefreshRate },
+   { "GetRefreshRate" ,             RenderTaskApi::GetRefreshRate },
+
+};
+
+const unsigned int RenderTaskFunctionTableCount = sizeof(RenderTaskFunctionTable)/sizeof(RenderTaskFunctionTable[0]);
+} //un-named space
+
+
+RenderTaskWrapper::RenderTaskWrapper( const Dali::RenderTask& renderTask, GarbageCollectorInterface& gc )
+:  HandleWrapper(  BaseWrappedObject::RENDER_TASK , renderTask, gc )
+{
+    mRenderTask = renderTask;
+}
+
+v8::Handle RenderTaskWrapper::WrapRenderTask(v8::Isolate* isolate, const Dali::RenderTask& renderTask )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetRenderTaskTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the RenderTask wrapper
+  RenderTaskWrapper* pointer =  new RenderTaskWrapper( renderTask, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local RenderTaskWrapper::GetRenderTaskTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  if( mRenderTaskTemplate.IsEmpty() )
+  {
+    objectTemplate = MakeRenderTaskTemplate( isolate );
+    mRenderTaskTemplate.Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, mRenderTaskTemplate );
+  }
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle RenderTaskWrapper::MakeRenderTaskTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  // property handle intercepts property getters and setters and signals
+  HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, RenderTaskFunctionTable, RenderTaskFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+
+RenderTask RenderTaskWrapper::GetRenderTask()
+{
+  return mRenderTask;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/render-tasks/render-task-wrapper.h b/plugins/dali-script-v8/src/render-tasks/render-task-wrapper.h
new file mode 100644
index 0000000..ab88f87
--- /dev/null
+++ b/plugins/dali-script-v8/src/render-tasks/render-task-wrapper.h
@@ -0,0 +1,77 @@
+#ifndef __DALI_V8PLUGIN_SHADER_EFFECT_WRAPPER_H__
+#define __DALI_V8PLUGIN_SHADER_EFFECT_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An RenderTask  wrapper.
+ * Provides access to RenderTask specific functionality and V8 memory handling.
+ */
+class RenderTaskWrapper : public HandleWrapper
+{
+
+public:
+
+  RenderTaskWrapper( const RenderTask& shaderEffect,
+                GarbageCollectorInterface& gc );
+
+  virtual ~RenderTaskWrapper() {}
+
+
+  /**
+   * Wraps a render task
+   */
+  static v8::Handle WrapRenderTask(v8::Isolate* isolate, const Dali::RenderTask& );
+
+
+  // The RenderTaskAttribute ObjectTemplate, we cache templates so we don't have
+  // keep generating them everytime we want to create an RenderTask
+  static v8::Persistent mRenderTaskTemplate;
+
+  RenderTask GetRenderTask();
+
+
+private:
+
+  // RenderTask
+  RenderTask mRenderTask;
+
+  static v8::Handle MakeRenderTaskTemplate( v8::Isolate* isolate );
+  static v8::Local GetRenderTaskTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_SHADER_EFFECT_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/shader-effects/shader-effect-api.cpp b/plugins/dali-script-v8/src/shader-effects/shader-effect-api.cpp
new file mode 100644
index 0000000..74762f2
--- /dev/null
+++ b/plugins/dali-script-v8/src/shader-effects/shader-effect-api.cpp
@@ -0,0 +1,423 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// CLASS HEADER
+#include "shader-effect-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+typedef  std::vector< std::string > HintsArray;
+
+
+struct GeometryTypePair
+{
+  const char* name;
+  GeometryType type;
+};
+
+const GeometryTypePair GeometryTypeTable[]=
+{
+    {"image",         GEOMETRY_TYPE_IMAGE },
+    {"text",          GEOMETRY_TYPE_TEXT  },
+    {"mesh",          GEOMETRY_TYPE_UNTEXTURED_MESH  },
+    {"textured-mesh", GEOMETRY_TYPE_TEXTURED_MESH },
+};
+
+const unsigned int GeometryTypeTableCount = sizeof(GeometryTypeTable)/sizeof(GeometryTypeTable[0]);
+
+struct GeometryHintPair
+{
+  const char* name;
+  ShaderEffect::GeometryHints hint;
+};
+
+const GeometryHintPair GeometryHintTable[]=
+{
+    {"gridX",        ShaderEffect::HINT_GRID_X },
+    {"gridY",        ShaderEffect::HINT_GRID_Y },
+    {"grid",         ShaderEffect::HINT_GRID   },
+    {"depthBuffer",  ShaderEffect::HINT_DEPTH_BUFFER },
+    {"blending",     ShaderEffect::HINT_BLENDING },
+    {"doesntModifyGeometry", ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY }
+};
+
+const unsigned int GeometryHintTableCount = sizeof(GeometryHintTable)/sizeof(GeometryHintTable[0]);
+
+
+
+
+struct ShaderParameters
+{
+  ShaderParameters()
+      : mType( GEOMETRY_TYPE_IMAGE),
+        mHints( ShaderEffect::HINT_NONE )
+  {
+  }
+
+  void SetGeometryType( v8::Isolate* isolate, const std::string& typeName )
+  {
+     for( unsigned int i = 0; i < GeometryTypeTableCount; ++i )
+     {
+       if( typeName == GeometryTypeTable[i].name )
+       {
+         mType = GeometryTypeTable[i].type;
+         return;
+       }
+     }
+     DALI_SCRIPT_EXCEPTION( isolate, "Geometry type not found\n");
+  }
+
+  ShaderEffect::GeometryHints GetGeometryHint( const std::string& hint )
+  {
+    for( unsigned int i = 0 ; i < GeometryHintTableCount; ++i )
+    {
+      if( hint == GeometryHintTable[i].name )
+      {
+        return GeometryHintTable[i].hint;
+      }
+    }
+    return ShaderEffect::HINT_NONE;
+  }
+
+  void ProcessHintsArray( const HintsArray& hintsArray )
+  {
+    for( HintsArray::const_iterator iter  = hintsArray.begin(); iter != hintsArray.end() ; ++iter )
+    {
+      mHints= static_cast( mHints | GetGeometryHint( *iter ) );
+    }
+  }
+
+
+
+  ShaderEffect NewShader()
+  {
+    return ShaderEffect::NewWithPrefix( mVertexPrefix ,
+                              mVertex,
+                              mFragmentPrefix,
+                              mFragment,
+                              mType,
+                              mHints);
+  }
+  std::string mVertexPrefix;
+  std::string mVertex;
+  std::string mFragmentPrefix;
+  std::string mFragment;
+  GeometryType mType;
+  ShaderEffect::GeometryHints mHints;
+};
+
+ShaderEffect GetShaderEffect( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  ShaderEffectWrapper* wrapper = static_cast< ShaderEffectWrapper *>(ptr);
+  return wrapper->GetShaderEffect();
+}
+
+} // unnamed space
+
+/**
+ * Create a new ShaderEffect
+ * @constructor
+ * @for ShaderEffect
+ * @method ShaderEffect
+ * @param {Object} shaderOptions
+ * @param {String} [shaderOptions.geometryType] Type of geometry to be rendered with the effect. "image", "text", "mesh", "textured-mesh", default is image.
+ * @param {String} [shaderOptions.vertexShaderPrefix] This string will be inserted before the default uniforms for the vertex shader(ideal for #defines)
+ * @param {String} [shaderOptions.vertexShader] VertexShader code for the effect. If not defined, the default version will be used
+ * @param {String} [shaderOptions.fragmentShaderPrefix] This string will be inserted before the default uniforms for the fragment shader(ideal for #defines)
+ * @param {String} [shaderOptions.fragmentShader] FragmentShader code for the effect. If not defined, the default version will be used
+ * @param {Array}  [shaderOptions.geometryHints] Hints for rendering the geometry, e.g.  [ "gridX", "gridY", "grid","depthBuffer","blending","doesntModifyGeometry" ]
+ * @return {Object} ShaderEffect
+ * @example
+
+      // this will match the default shaders for image
+      var vertexShader = " void main() \
+      { \
+        gl_Position = uProjection * uModelView * vec4(aPosition, 1.0); \
+        vTexCoord = aTexCoord; \
+      }; "
+     var fragShader = " void main() \
+      { \
+       gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\
+      }; "
+      var shaderOptions = {
+            geometryType: "image",
+            vertexShader: vertexShader,
+            fragmentShader: fragShader
+      };
+
+      var shader = new dali.ShaderEffect(shaderOptions);
+
+      imageActor.setShaderEffect( shader );
+
+ *
+ *
+ *
+ */
+ShaderEffect ShaderEffectApi::New(  v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+
+
+  v8::HandleScope handleScope( isolate );
+
+  ShaderParameters shaderParams;
+
+  if( args[0]->IsObject() )
+  {
+    v8::Local obj = args[0]->ToObject();
+
+    v8::Local geometryTypeValue = obj->Get(v8::String::NewFromUtf8( isolate, "geometryType"));
+    if( geometryTypeValue->IsString() )
+    {
+      std::string geometryTypeName = V8Utils::v8StringToStdString( geometryTypeValue );
+     // printf(" geometry type found %s \n", geometryTypeName.c_str() );
+      shaderParams.SetGeometryType( isolate, geometryTypeName );
+    }
+
+    v8::Local vertexPrefixValue = obj->Get(v8::String::NewFromUtf8( isolate, "vertexShaderPrefix"));
+    if( vertexPrefixValue->IsString() )
+    {
+      shaderParams.mVertexPrefix = V8Utils::v8StringToStdString( vertexPrefixValue );
+    }
+
+    v8::Local fragmentPrefixValue = obj->Get(v8::String::NewFromUtf8( isolate, "fragmentShaderPrefix"));
+    if( fragmentPrefixValue->IsString() )
+    {
+      shaderParams.mFragmentPrefix = V8Utils::v8StringToStdString( fragmentPrefixValue );
+    }
+
+    v8::Local vertexValue = obj->Get(v8::String::NewFromUtf8( isolate, "vertexShader"));
+    if( vertexValue->IsString() )
+    {
+      shaderParams.mVertex = V8Utils::v8StringToStdString( vertexValue );
+    }
+
+    v8::Local fragmentValue = obj->Get(v8::String::NewFromUtf8( isolate, "fragmentShader"));
+    if( fragmentValue->IsString() )
+    {
+      shaderParams.mFragment = V8Utils::v8StringToStdString( fragmentValue );
+    }
+    // Get any hints
+    v8::Local hints = obj->Get(v8::String::NewFromUtf8( isolate, "geometryHints"));
+    if( hints->IsArray() )
+    {
+      HintsArray hintsArray;
+      v8::Local array = v8::Local::Cast( hints );
+      for( uint32_t i=0; i <  array->Length(); ++i)
+      {
+        v8::Handle entry = array->Get(  v8::Integer::New( isolate, i) );
+        if( entry->IsString() )
+        {
+          std::string entryString = V8Utils::v8StringToStdString( entry );
+          hintsArray.push_back( entryString );
+        }
+      }
+      shaderParams.ProcessHintsArray( hintsArray );
+    }
+  }
+  return shaderParams.NewShader();
+
+}
+
+ShaderEffect ShaderEffectApi::GetShaderEffectFromParams( int paramIndex,
+                          bool& found,
+                          v8::Isolate* isolate,
+                          const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  found = false;
+
+  v8::HandleScope handleScope( isolate );
+  BaseWrappedObject* wrappedObject = V8Utils::GetWrappedDaliObjectParameter( paramIndex, BaseWrappedObject::SHADER_EFFECT, isolate, args );
+  if( wrappedObject )
+  {
+    found = true;
+    ShaderEffectWrapper* wrapper = static_cast< ShaderEffectWrapper *>(wrappedObject);
+    return wrapper->GetShaderEffect();
+  }
+  else
+  {
+    return ShaderEffect();
+  }
+}
+
+/**
+ * Set a shader effect image.
+ * This image texture will be bound to the "sEffect" sampler
+ * so it can be used in fragment shader for effects
+ * @method setEffectImage
+ * @for ShaderEffect
+ * @param {Object} image
+ * @example
+ *
+ *      shader.setEffectImage( image );
+ *
+ *      // example of a fragment shader than can use the effect image (sEffect and main texture sTexture)
+ *
+ *      "void main() \
+ *       { \
+ *        vec4 v4Color  = (texture2D(sTexture, vTexCoord) * uColor); \
+ *        v4Color = v4Color*  texture2D(sEffect, vTexCoord);\
+ *        gl_FragColor = v4Color; \"
+ *      }";
+ */
+void ShaderEffectApi::SetEffectImage( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  Image image = V8Utils::GetImageParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, " Image::SetEffectImage invalid params");
+    return;
+  }
+  ShaderEffect effect =  GetShaderEffect( isolate, args );
+  effect.SetEffectImage( image );
+}
+
+
+/**
+ * Sets and registers a uniform property.
+ * If name matches a uniform in the shader source, this value will be uploaded when rendering.
+ * This uniform can then be animated / modified and the change will be made to the shader.
+ * @method setUniform
+ * @for ShaderEffect
+ * @param {String} name
+ * @param {Object} value must be a: float, vector2 vector3, vector4, matrix
+ * @param {String} [uniformCoordinateType] The coordinate type of the uniform.
+ * either "viewPortPosition" or "viewPortDirection"
+ * @example
+
+      var fragShader =
+      " uniform lowp vec4 uColorShift; \
+      \
+       void main()             \
+       {                  \
+
+         gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor + uColorShift; \
+       }"
+
+      var shaderOptions = {
+          geometryType: "image",
+          fragmentShader: fragShader
+      };
+
+      // create a new shader effect
+      var shader = new dali.ShaderEffect(shaderOptions);
+
+      // add the color shift uniform so we can animate it
+      // default the color shift to zero, so it has no effect
+      shader.setUniform("uColorShift", [0.0, 0.0, 0.0, 0]);
+ */
+void ShaderEffectApi::SetUniform( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  ShaderEffect effect =  GetShaderEffect( isolate, args );
+
+  bool found(false);
+  std::string uniformName = V8Utils::GetStringParameter( PARAMETER_0 , found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "SetUniform: uniform name not found\n");
+    return;
+  }
+
+  Property::Value propValue = V8Utils::GetPropertyValueParameter( PARAMETER_1 , found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "SetUniform: value not found\n");
+    return;
+  }
+
+  std::string coordinateType = V8Utils::GetStringParameter( PARAMETER_2, found, isolate, args );
+  ShaderEffect::UniformCoordinateType uniformCoordinateType( ShaderEffect::COORDINATE_TYPE_DEFAULT );
+  if( found )
+  {
+    if( coordinateType == "viewPortPosition")
+    {
+      uniformCoordinateType = ShaderEffect::COORDINATE_TYPE_VIEWPORT_POSITION;
+    }
+    else if ( coordinateType == "viewPortDirection ")
+    {
+      uniformCoordinateType = ShaderEffect::COORDINATE_TYPE_VIEWPORT_DIRECTION;
+    }
+  }
+
+  switch( propValue.GetType() )
+  {
+    case Property::FLOAT:
+    {
+      effect.SetUniform( uniformName, propValue.Get(), uniformCoordinateType );
+      break;
+    }
+    case Property::VECTOR2:
+    {
+      effect.SetUniform( uniformName, propValue.Get(), uniformCoordinateType );
+      break;
+    }
+    case Property::VECTOR3:
+    {
+      effect.SetUniform( uniformName, propValue.Get(), uniformCoordinateType );
+      break;
+    }
+    case Property::VECTOR4:
+    {
+      effect.SetUniform( uniformName, propValue.Get(), uniformCoordinateType );
+      break;
+    }
+    case Property::MATRIX:
+    {
+      effect.SetUniform( uniformName, propValue.Get(), uniformCoordinateType );
+      break;
+    }
+    case Property::MATRIX3:
+    {
+      effect.SetUniform( uniformName, propValue.Get(), uniformCoordinateType );
+      break;
+    }
+    default:
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "value type not recognised \n");
+      break;
+    }
+  }
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/shader-effects/shader-effect-api.h b/plugins/dali-script-v8/src/shader-effects/shader-effect-api.h
new file mode 100644
index 0000000..3b2534a
--- /dev/null
+++ b/plugins/dali-script-v8/src/shader-effects/shader-effect-api.h
@@ -0,0 +1,57 @@
+#ifndef __DALI_V8PLUGIN_SHADER_EFFECT_API_H__
+#define __DALI_V8PLUGIN_SHADER_EFFECT_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ShaderEffectApi
+{
+
+  /**
+   * Constructor
+   */
+   ShaderEffect New( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+   ShaderEffect GetShaderEffectFromParams( int paramIndex,
+                             bool& found,
+                             v8::Isolate* isolate,
+                             const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * ShaderEffect API see shader-effect.h for a description
+   */
+  void SetEffectImage( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetUniform( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace ShaderEffectApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_SHADER_EFFECT_API_H__
diff --git a/plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.cpp b/plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.cpp
new file mode 100644
index 0000000..04ae5fa
--- /dev/null
+++ b/plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.cpp
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "shader-effect-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+v8::Persistent ShaderEffectWrapper::mShaderEffectTemplate;
+
+namespace // un-named name space
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction ShaderEffectFunctionTable[]=
+{
+    /**************************************
+    * ShaderEffect API (in order of shaderEffect.h)
+    **************************************/
+
+   { "SetEffectImage"             , ShaderEffectApi::SetEffectImage },
+   { "SetUniform"                 , ShaderEffectApi::SetUniform     },
+};
+
+const unsigned int ShaderEffectFunctionTableCount = sizeof(ShaderEffectFunctionTable)/sizeof(ShaderEffectFunctionTable[0]);
+} //un-named space
+
+
+ShaderEffectWrapper::ShaderEffectWrapper( const Dali::ShaderEffect& shaderEffect, GarbageCollectorInterface& gc )
+:  HandleWrapper(  BaseWrappedObject::SHADER_EFFECT , shaderEffect, gc )
+{
+    mShaderEffect = shaderEffect;
+}
+
+v8::Handle ShaderEffectWrapper::WrapShaderEffect(v8::Isolate* isolate, const Dali::ShaderEffect& shaderEffect )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetShaderEffectTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the ShaderEffect wrapper
+  ShaderEffectWrapper* pointer =  new ShaderEffectWrapper( shaderEffect, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local ShaderEffectWrapper::GetShaderEffectTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  if( mShaderEffectTemplate.IsEmpty() )
+  {
+    objectTemplate = MakeShaderEffectTemplate( isolate );
+    mShaderEffectTemplate.Reset( isolate, objectTemplate );
+  }
+  else
+  {
+    // get the object template
+    objectTemplate = v8::Local::New( isolate, mShaderEffectTemplate );
+  }
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle ShaderEffectWrapper::MakeShaderEffectTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  // property handle intercepts property getters and setters and signals
+  HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, ShaderEffectFunctionTable, ShaderEffectFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+void ShaderEffectWrapper::NewShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if(!args.IsConstructCall())
+  {
+      DALI_SCRIPT_EXCEPTION( isolate, "ShaderEffect constructor called without 'new'");
+      return;
+  }
+  Dali::ShaderEffect shaderEffect = ShaderEffectApi::New( isolate, args );
+
+  v8::Local localObject = WrapShaderEffect( isolate, shaderEffect );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+ShaderEffect ShaderEffectWrapper::GetShaderEffect()
+{
+  return mShaderEffect;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.h b/plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.h
new file mode 100644
index 0000000..0a4f5f7
--- /dev/null
+++ b/plugins/dali-script-v8/src/shader-effects/shader-effect-wrapper.h
@@ -0,0 +1,84 @@
+#ifndef __DALI_V8PLUGIN_SHADER_EFFECT_WRAPPER_H__
+#define __DALI_V8PLUGIN_SHADER_EFFECT_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An ShaderEffect  wrapper.
+ * Provides access to ShaderEffect specific functionality and V8 memory handling.
+ */
+class ShaderEffectWrapper : public HandleWrapper
+{
+
+public:
+
+  ShaderEffectWrapper( const ShaderEffect& shaderEffect,
+                GarbageCollectorInterface& gc );
+
+  virtual ~ShaderEffectWrapper()
+  {
+  };
+
+  /**
+   * @brief Creates a new ShaderEffect wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps a  shaderEffect
+   */
+  static v8::Handle WrapShaderEffect(v8::Isolate* isolate, const Dali::ShaderEffect& );
+
+
+  // The ShaderEffectAttribute ObjectTemplate, we cache templates so we don't have
+  // keep generating them everytime we want to create an ShaderEffect
+  static v8::Persistent mShaderEffectTemplate;
+
+  ShaderEffect GetShaderEffect();
+
+
+private:
+
+  // ShaderEffect
+  ShaderEffect mShaderEffect;
+
+  static v8::Handle MakeShaderEffectTemplate( v8::Isolate* isolate );
+  static v8::Local GetShaderEffectTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_SHADER_EFFECT_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/shared/api-function.h b/plugins/dali-script-v8/src/shared/api-function.h
new file mode 100644
index 0000000..acb3f25
--- /dev/null
+++ b/plugins/dali-script-v8/src/shared/api-function.h
@@ -0,0 +1,54 @@
+#ifndef __DALI_V8PLUGIN_API_FUNCTION_H__
+#define __DALI_V8PLUGIN_API_FUNCTION_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * @brief Used for mapping a string to a static function, for defining functions that are exposed to JavaScript.
+ * E.g.
+ * @code
+ * const ApiFunction AnimationFunctionTable[]=
+ * {
+ *  { "setDuration"             , AnimationApi::SetDuration  },
+ *  { "getDuration"             , AnimationApi::GetDuration  },
+ *  { "setLooping"              , AnimationApi::SetLooping   },
+ * }
+ * @endcode
+ */
+struct ApiFunction
+{
+  const char* const name;      ///< function name
+  void (*function)( const v8::FunctionCallbackInfo< v8::Value >& args);
+};
+
+
+} // V8Plugin
+
+} // Dali
+
+#endif
diff --git a/plugins/dali-script-v8/src/shared/base-wrapped-object.cpp b/plugins/dali-script-v8/src/shared/base-wrapped-object.cpp
new file mode 100644
index 0000000..0963ea3
--- /dev/null
+++ b/plugins/dali-script-v8/src/shared/base-wrapped-object.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "base-wrapped-object.h"
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+BaseWrappedObject::BaseWrappedObject( Type type, GarbageCollectorInterface& gc )
+: mWrappedType( type ),
+  mGarbageCollector( gc  )
+{
+  mGarbageCollector.Register( this );
+}
+
+BaseWrappedObject::~BaseWrappedObject()
+{
+  mGarbageCollector.UnRegister( this );
+}
+
+bool BaseWrappedObject::IsReferenced()
+{
+  if( mWeakPersistentHandle.IsEmpty() )
+  {
+    return false;
+  }
+  if( mWeakPersistentHandle.IsNearDeath() )
+  {
+    return false;
+  }
+  return true;
+}
+void BaseWrappedObject::WeakCallback( const v8::WeakCallbackData& data)
+{
+  BaseWrappedObject* wrappedObject = data.GetParameter();
+  wrappedObject->mWeakPersistentHandle.Reset();  // moved from destructor due to crash on shutdown
+  delete wrappedObject;
+}
+
+void BaseWrappedObject::SetJavascriptObject( v8::Isolate* isolate, v8::Local& object )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Handle ptr = v8::External::New( isolate, this );
+  object->SetInternalField( FIELD_POINTER, ptr );
+
+  v8::Local theType = v8::Integer::New( isolate ,mWrappedType );
+  object->SetInternalField( FIELD_TYPE, theType );
+
+  // reset sets the the handle
+  mWeakPersistentHandle.Reset( isolate, object );
+
+  // set the weak call back which is triggered when nothing else is referencing the object
+  // note, this may never called.
+  mWeakPersistentHandle.SetWeak( this, &WeakCallback );
+}
+
+bool BaseWrappedObject::IsWrappedType(v8::Isolate* isolate, const v8::Local& object,  BaseWrappedObject::Type type)
+{
+  v8::HandleScope handleScope( isolate );
+
+  // we've been passed a javascript object, it could be anything!
+  // so we safely check the internal field count matches the number of fields
+  // in BaseWrappedObject. Then check if the second field is an integer value
+  // possibly alternative v8 functions we could use
+  // GetConstructorName
+  // GetIdentityHash
+  if( object->InternalFieldCount() == BaseWrappedObject::FIELD_COUNT )
+  {
+    v8::Handle value = object->GetInternalField(BaseWrappedObject::FIELD_TYPE);
+
+    if( value->IsInt32() )
+    {
+      BaseWrappedObject::Type objectType = static_cast( value->ToInt32()->Value());
+      return (type == objectType);
+    }
+  }
+  return false;
+}
+
+bool BaseWrappedObject::IsWrappedTypeAPropertyValue(const v8::Local& object)
+{
+
+   if( object->InternalFieldCount() == BaseWrappedObject::FIELD_COUNT )
+   {
+     v8::Handle value = object->GetInternalField(BaseWrappedObject::FIELD_TYPE);
+
+     if( value->IsInt32() )
+     {
+       BaseWrappedObject::Type objectType = static_cast( value->ToInt32()->Value());
+       return ( (objectType > PROPERTY_VALUE_START_RANGE) && ( objectType < PROPERTY_VALUE_END_RANGE) );
+     }
+   }
+   return false;
+}
+
+BaseWrappedObject* BaseWrappedObject::UnWrap( v8::Isolate* isolate, const v8::Local& object)
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local field = v8::Local::Cast( object->GetInternalField(BaseWrappedObject::FIELD_POINTER) );
+  void* ptr = field->Value();
+  return static_cast< BaseWrappedObject *>(ptr);
+}
+
+BaseWrappedObject::Type BaseWrappedObject::GetType()
+{
+  return  mWrappedType;
+}
+
+SignalManager* BaseWrappedObject::GetSignalManager()
+{
+  return NULL;
+}
+} // V8Plugin
+
+} // Dali
+
diff --git a/plugins/dali-script-v8/src/shared/base-wrapped-object.h b/plugins/dali-script-v8/src/shared/base-wrapped-object.h
new file mode 100644
index 0000000..7e473cd
--- /dev/null
+++ b/plugins/dali-script-v8/src/shared/base-wrapped-object.h
@@ -0,0 +1,185 @@
+#ifndef __DALI_V8PLUGIN_BASE_WRAPPED_OBJECT_H__
+#define __DALI_V8PLUGIN_BASE_WRAPPED_OBJECT_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+class SignalManager;
+
+/**
+ * @brief Used as a base class for all wrapped objects.
+ *
+ *  Dali JavaScript objects look like this
+ *
+ * \code
+ *  _______________________________________         ________________________________________
+ * | JavaScript Object                     |       |  C++ WrappedObject  (e.g. ImageWrapper)|
+ * |---------------------------------------|       |----------------------------------------|
+ * | Hidden internal fields                |       | Handle to a Dali::Image object         |
+ * | *Pointer to a BaseWrappedObject       | ----> |________________________________________|
+ * | Type of wrapped object (e.g. Image)   |
+ * -----------------------------------------
+ *
+ * \endcode
+ *
+ * Whenever we want to access functions / properties of that wrapped object, we unwrap it
+ * to get access to the Dali object.
+ *
+ * Each wrapped object registers with Dali garbage collector so they can be deleted
+ * when Dali shuts down
+ */
+class BaseWrappedObject
+{
+
+public:
+
+  /*
+   * A type enum for the wrapped object
+   */
+  enum Type
+    {
+      UNKNOWN              = -1,
+      HANDLE               = 0 ,
+      HANDLE_SIGNAL,
+      CONNECTION,
+      ANIMATION,
+      PATH,
+      BUILDER,
+      STAGE,
+      FONT,
+      IMAGE,
+      IMAGE_ATTRIBUTES,
+      ACTOR,
+      ACTOR_PROPERTY,
+      RENDER_TASK,
+      RENDER_TASK_LIST,
+      TIMER,
+      TAP_GESTURE,
+      SHADER_EFFECT,
+      PAN_GESTURE,
+      LONGPRESS_GESTURE,
+      PINCH_GESTURE,
+      KEYBOARD_FOCUS_MANAGER,
+      PAN_GESTURE_DETECTOR,
+      ////////////////////////////////////////////////////////
+      PROPERTY_VALUE_START_RANGE,  // start of property values
+      VECTOR2,
+      VECTOR3,
+      VECTOR4,
+      MATRIX,
+      MATRIX3,
+      RECTANGLE,
+      ROTATION,
+      PROPERTY_VALUE_END_RANGE,  // end of property values
+      ///////////////////////////////////////////////////////
+    };
+
+  /*
+   * A type enum for the wrapped object internal field
+   */
+  enum Field
+    {
+      FIELD_POINTER   = 0,
+      FIELD_TYPE      = 1,
+      FIELD_COUNT     = 2 // increase if more fields are added
+    };
+
+   /**
+   * @brief virtual destructor
+   */
+  virtual ~BaseWrappedObject();
+
+  /**
+   * @return true if nothing else is referencing this object
+   */
+  bool IsReferenced();
+
+  /**
+   * @brief Called when the v8 garbage collector decides the JavaScript object (which contains the Dali wrapped object)
+   * is no longer used / reachable.
+   */
+  static void WeakCallback( const v8::WeakCallbackData& data);
+
+  /**
+   * @brief create and set the internal fields of a JavaScript object.
+   * Currently has 2 internal fields, 1 is a pointer to dali wrapped object, 2nd is the type.
+   */
+  void SetJavascriptObject( v8::Isolate* isolate, v8::Local& object );
+
+  /**
+   * @return true if the object is of a certain wrapped type (e.g. ImageActor )
+   */
+  static bool IsWrappedType( v8::Isolate* isolate, const v8::Local& object,  BaseWrappedObject::Type type);
+
+  /**
+   * @return true if the object is a wrapped property value
+   */
+  static bool IsWrappedTypeAPropertyValue(const v8::Local& object);
+
+  /**
+   * @brief Extracts the Dali wrapped object from the javascript object
+   */
+  static BaseWrappedObject* UnWrap( v8::Isolate* isolate, const v8::Local& object);
+
+  /**
+   * @return the wrapped type
+   */
+  Type GetType();
+
+  virtual SignalManager* GetSignalManager();
+
+protected:
+
+  /**
+   * Constructor
+   * @param type wrapped type
+   * @param gc garbage collector interface
+   */
+  BaseWrappedObject( Type type, GarbageCollectorInterface& gc );
+
+private:
+
+  BaseWrappedObject();
+
+  /**
+   * We store a  persistent handle to the JavaScript object and then set it to weak.
+   * This means we be notified when v8 decides it's no longer required and we can delete
+   * the associated Dali object
+   */
+  v8::Persistent mWeakPersistentHandle;
+  Type mWrappedType;                                    ///< wrapped type
+  GarbageCollectorInterface& mGarbageCollector;         ///< Dali garbage collector
+};
+
+} // V8Plugin
+
+} // Dali
+
+#endif // header __DALI_V8PLUGIN_DALI_OBJECT_LIFETIME_MANAGER_H__
diff --git a/plugins/dali-script-v8/src/shared/object-template-helper.cpp b/plugins/dali-script-v8/src/shared/object-template-helper.cpp
new file mode 100644
index 0000000..3510523
--- /dev/null
+++ b/plugins/dali-script-v8/src/shared/object-template-helper.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// HEADER
+#include "object-template-helper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ObjectTemplateHelper
+{
+
+void AddSignalConnectAndDisconnect( v8::Isolate* isolate,  v8::Local& objTemplate )
+{
+  objTemplate->Set( v8::String::NewFromUtf8( isolate, "connect"),
+                     v8::FunctionTemplate::New( isolate, SignalManager::SignalConnect) );
+
+
+
+  objTemplate->Set( v8::String::NewFromUtf8( isolate, "disconnect"),
+                     v8::FunctionTemplate::New( isolate, SignalManager::SignalDisconnect) );
+}
+
+
+
+
+void InstallFunctions( v8::Isolate* isolate,
+                              v8::Local& objTemplate,
+                              const ApiFunction* functionTable,
+                              unsigned int tableCount,
+                              FunctionType type )
+{
+  // add our function properties
+   for( unsigned int i = 0; i < tableCount; ++i )
+   {
+     const ApiFunction property =  functionTable[i];
+
+     std::string funcName;
+
+     if( type == NORMAL_FUNCTIONS )
+     {
+       funcName = V8Utils::GetJavaScriptFunctionName( property.name);
+     }
+     else
+     {
+
+       funcName = property.name;
+     }
+    // printf("Installing function %s \n",      funcName.c_str()     );
+     objTemplate->Set( v8::String::NewFromUtf8(   isolate, funcName.c_str() ),
+                      v8::FunctionTemplate::New( isolate, property.function ) );
+   }
+}
+
+} // ObjectTemplateHelper
+
+} // V8Plugin
+
+} // Dali
diff --git a/plugins/dali-script-v8/src/shared/object-template-helper.h b/plugins/dali-script-v8/src/shared/object-template-helper.h
new file mode 100644
index 0000000..df027eb
--- /dev/null
+++ b/plugins/dali-script-v8/src/shared/object-template-helper.h
@@ -0,0 +1,66 @@
+#ifndef __DALI_V8PLUGIN_OBJECT_TEMPLATE_HELPER_H__
+#define __DALI_V8PLUGIN_OBJECT_TEMPLATE_HELPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace ObjectTemplateHelper
+{
+
+
+
+/**
+ * @brief Used for adding signal connect / disconnect functionality to an object template
+ * E.g.
+ */
+void AddSignalConnectAndDisconnect( v8::Isolate* isolate,  v8::Local& objTemplate );
+
+enum FunctionType
+{
+  NORMAL_FUNCTIONS = 0,
+  CONSTRUCTOR_FUNCTIONS = 1
+};
+
+/**
+ * Installs a list of functions on to an object template (e.g. actor.add, actor.setDrawMode() )
+ */
+void InstallFunctions( v8::Isolate* isolate,
+                              v8::Local& objTemplate,
+                              const ApiFunction* functionTable,
+                              unsigned int tableCount,
+                              FunctionType type = NORMAL_FUNCTIONS);
+
+
+}
+} // V8Plugin
+
+} // Dali
+
+#endif // __DALI_V8PLUGIN_OBJECT_TEMPLATE_HELPER_H__
diff --git a/plugins/dali-script-v8/src/signals/dali-any-javascript-converter.cpp b/plugins/dali-script-v8/src/signals/dali-any-javascript-converter.cpp
new file mode 100644
index 0000000..883fcbe
--- /dev/null
+++ b/plugins/dali-script-v8/src/signals/dali-any-javascript-converter.cpp
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "dali-any-javascript-converter.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+v8::Local DaliAnyConverter::ConvertToJavaScriptObject(v8::Isolate* isolate, Dali::Any& value )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local returnValue;
+
+  const std::type_info& typeInfo( value.GetType());
+
+  // check the type of the Any and convert it to a JavaScript object
+  // if we wanted to speed this up, it would be possible to hash the typeInfo.name() field.
+
+  if( typeInfo == typeid( Dali::Actor ))
+  {
+    Actor actor =  value.Get();
+    if( actor )
+    {
+      returnValue = ActorWrapper::WrapActor( isolate, actor );
+    }
+    else
+    {
+      returnValue = v8::Undefined( isolate );
+    }
+  }
+  else if(  typeInfo == typeid( std::string ) )
+  {
+
+    std::string string = value.Get< std::string >();
+    //printf(" converting %s to a javascript object \n", string.c_str());
+    returnValue =  v8::String::NewFromUtf8( isolate, string.c_str());
+  }
+  else if(  typeInfo == typeid( Dali::Vector3 ) )
+  {
+    returnValue = PropertyValueWrapper::WrapDaliProperty( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::TouchEvent ) )
+  {
+    returnValue = EventObjectGenerator::CreateTouchEvent( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::HoverEvent ) )
+  {
+    returnValue = EventObjectGenerator::CreateHoverEvent( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::MouseWheelEvent ) )
+  {
+    returnValue = EventObjectGenerator::CreateMouseWheelEvent( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::KeyEvent ) )
+  {
+    returnValue = EventObjectGenerator::CreateKeyEvent( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::PanGesture ) )
+  {
+    returnValue = EventObjectGenerator::CreatePanGesture( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::Animation ) )
+  {
+    returnValue = AnimationWrapper::WrapAnimation( isolate, value.Get() );
+  }
+  else if(  typeInfo == typeid( Dali::Image ) )
+  {
+    returnValue = ImageWrapper::WrapImage( isolate, value.Get() );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, " Failed to find Dali::Any to JavaScript converter \n" );
+  }
+
+  return handleScope.Escape( returnValue );
+}
+
+Dali::Any DaliAnyConverter::ConvertToDaliAny( v8::Isolate* isolate, v8::Local value, const Dali::Any& requestedType)
+{
+  v8::HandleScope handleScope( isolate );
+
+  if( value.IsEmpty() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Callback missing a return value \n");
+    return Dali::Any();
+  }
+  // try to match the return value types
+  if( requestedType.GetType() == typeid( bool ))
+  {
+    if( value->IsBoolean() )
+    {
+      return value->ToBoolean()->Value();
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "Invalid return type from callback, wanted a bool \n");
+    }
+  }
+  else if( requestedType.GetType() == typeid( unsigned int ) )
+  {
+    if( value->IsUint32() )
+    {
+      return value->ToUint32()->Value();
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION( isolate, "Invalid return type from callback, wanted an unsigned int\n");
+    }
+  }
+  // allow positive and negative numbers for int,@todo test how v8 behaves with numbers returned
+  else if( requestedType.GetType() == typeid( int ))
+  {
+    if( value->IsInt32() )
+    {
+      return value->ToInt32()->Value();
+    }
+    else if( value->IsUint32() )
+    {
+      return static_cast( value->ToUint32()->Value());
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION(isolate, "Invalid return type from callback, wanted an int\n");
+    }
+  }
+  else if( requestedType.GetType() == typeid( float ))
+  {
+    if( value->IsNumber() )
+    {
+      return value->ToNumber()->Value();
+    }
+    else if( value->IsInt32() )
+    {
+      return static_cast(value->ToInt32()->Value());
+    }
+    else if( value->IsUint32() )
+    {
+      return static_cast( value->ToUint32()->Value() );
+    }
+    else
+    {
+      DALI_SCRIPT_EXCEPTION(isolate, "Invalid return type from callback, wanted a float\n");
+    }
+  }
+  else if( requestedType.GetType() == typeid( Actor ))
+  {
+    if( value->IsObject()  )
+    {
+      HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, value->ToObject() );
+      if( handleWrapper )
+      {
+        return Actor::DownCast( handleWrapper->mHandle );
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, "Invalid return type from callback, wanted an Actor \n");
+      }
+    }
+    else
+    {
+      // undefined is used to describe an empty actor handle
+      if (value->IsUndefined())
+      {
+        return Actor();
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, "missing return type, wanted an Actor \n");
+      }
+    }
+
+  }
+  return Dali::Any(); // empty any
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/signals/dali-any-javascript-converter.h b/plugins/dali-script-v8/src/signals/dali-any-javascript-converter.h
new file mode 100644
index 0000000..fa241f1
--- /dev/null
+++ b/plugins/dali-script-v8/src/signals/dali-any-javascript-converter.h
@@ -0,0 +1,55 @@
+#ifndef __DALI_V8PLUGIN_DALI_ANY_JAVASCRIPT_CONVERTER_H__
+#define __DALI_V8PLUGIN_DALI_ANY_JAVASCRIPT_CONVERTER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace DaliAnyConverter
+{
+
+
+/**
+ * Converts a Dali::Any object to a JavaScript object based on it's type
+ */
+v8::Local ConvertToJavaScriptObject( v8::Isolate* isolate, Dali::Any& value );
+
+
+/**
+ * Converts from a JavaScript object back into a Dali::Any object
+ * Used for return values from JavaScript callbacks
+ * E.g. to convert from a JavaScript bool object to a C++ bool
+ */
+
+Dali::Any ConvertToDaliAny( v8::Isolate* isolate, v8::Local, const Dali::Any& requestedType);
+
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_DALI_ANY_JAVASCRIPT_CONVERTER_H__
diff --git a/plugins/dali-script-v8/src/signals/emit-notification-interface.h b/plugins/dali-script-v8/src/signals/emit-notification-interface.h
new file mode 100644
index 0000000..8ba1d0f
--- /dev/null
+++ b/plugins/dali-script-v8/src/signals/emit-notification-interface.h
@@ -0,0 +1,65 @@
+#ifndef __DALI_V8PLUGIN_EMIT_NOTIFICATION_INTERFACE_H__
+#define __DALI_V8PLUGIN_EMIT_NOTIFICATION_INTERFACE_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * abstract interface to allow the signal manager know if
+ * a JavaScript disconnect/ connect has been called, while inside a callback
+ */
+class EmitNotificationInterface
+{
+
+  public:
+
+  /**
+   * Constructor
+   */
+  EmitNotificationInterface() {}
+
+  /**
+   * Virtual destructor
+   */
+  virtual ~EmitNotificationInterface() {}
+
+  /**
+   * Call back has been entered.
+   * E.g. Actor on touch has called a JavaScript function
+   */
+   virtual void CallbackEnter() =0 ;
+
+   /**
+    * Call back has been entered.
+    * E.g. Actor on touch has called a JavaScript function
+    */
+   virtual void CallbackExit() =0 ;
+
+};
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_EMIT_NOTIFICATION_INTERFACE_H__
diff --git a/plugins/dali-script-v8/src/signals/signal-manager.cpp b/plugins/dali-script-v8/src/signals/signal-manager.cpp
new file mode 100644
index 0000000..55d4a0e
--- /dev/null
+++ b/plugins/dali-script-v8/src/signals/signal-manager.cpp
@@ -0,0 +1,760 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "signal-manager.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un-named namespace
+{
+const char* const SIGNAL_TOUCHED = "touched";
+const char* const SIGNAL_HOVERED = "hovered";
+const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
+const char* const SIGNAL_ON_STAGE = "on-stage";
+const char* const SIGNAL_OFF_STAGE = "off-stage";
+const char* const ANIMATION_SIGNAL_FINISHED = "finished";
+const char* const SIGNAL_PAN_DETECTED = "pan-detected";
+
+const char* const STAGE_SIGNAL_KEY_EVENT = "key-event";
+const char* const STAGE_SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
+const char* const STAGE_SIGNAL_TOUCHED = "touched";
+const char* const SIGNAL_IMAGE_LOADING_FINISHED = "image-loading-finished";
+const char* const SIGNAL_IMAGE_UPLOADED = "uploaded";
+
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_PRE_FOCUS_CHANGE = "keyboard-pre-focus-change";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_CHANGED = "keyboard-focus-changed";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_GROUP_CHANGED = "keyboard-focus-group-changed";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUSED_ACTOR_ACTIVATED = "keyboard-focused-actor-activated";
+const unsigned int MAX_SIGNAL_NAME_LENGTH = 64;
+
+} // un-named name space
+
+class BaseJavaScriptCallback
+{
+public:
+
+  BaseJavaScriptCallback(  v8::Isolate* isolate,  const v8::Local& callback )
+  :mIsolate( isolate ),mEmitInterface( NULL )
+  {
+    mCallback.Reset( isolate, callback);
+  }
+  ~BaseJavaScriptCallback()
+  {
+    mCallback.Reset();
+  };
+
+  bool IsFunction( const v8::Local& function)
+  {
+    v8::HandleScope handleScope( mIsolate );
+    v8::Local localCallback =  v8::Local::New( mIsolate, mCallback );
+    return ( localCallback == function );
+  }
+
+  void Call( Dali::Any& returnValue, std::vector< Dali::Any >& data )
+  {
+    mEmitInterface->CallbackEnter();
+
+    v8::HandleScope handleScope( mIsolate );
+    v8::TryCatch tryCatch;
+
+    // create a vector of JavaScript arguments to pass to the JavaScript function
+    std::vector< v8::Local > arguments;
+
+    for( unsigned int i = 0; i < data.size(); ++i )
+    {
+      // convert each Dali::Any object into a JavaScript object based on it's type
+      arguments.push_back( DaliAnyConverter::ConvertToJavaScriptObject( mIsolate, data[i]));
+    }
+
+    // call the javascript function
+    v8::Local localCallback =  v8::Local::New( mIsolate, mCallback );
+    v8::Local  javaScriptReturnVal = v8::Local::Cast( localCallback->Call( localCallback, arguments.size(), &arguments[0] ));
+
+    // Print errors that happened during execution.
+    if( tryCatch.HasCaught() )
+    {
+      V8Utils::ReportException( mIsolate, &tryCatch);
+      DALI_ASSERT_ALWAYS( 0 && "Script error \n");
+    }
+
+    // convert will log an error, if the return type we want isn't found
+    returnValue = DaliAnyConverter::ConvertToDaliAny( mIsolate,  javaScriptReturnVal, returnValue );
+
+    mEmitInterface->CallbackExit();
+
+  }
+
+  void SetEmitInterface( EmitNotificationInterface* interface)
+  {
+    mEmitInterface = interface;
+  }
+protected:
+  v8::Isolate*                 mIsolate;
+  v8::Persistent mCallback;
+  EmitNotificationInterface*   mEmitInterface;
+
+};
+/**
+ * base class for callback
+ */
+class BaseCallBack : public ConnectionTracker
+{
+public:
+    BaseCallBack( v8::Isolate* isolate,  const v8::Local& callback, const std::string& signalName )
+    :mSignalName( signalName ),
+     mJavaFunctor( isolate, callback)
+    {
+
+    }
+    void CallJavaScript(  Dali::Any& returnValue, std::vector< Dali::Any >& data )
+    {
+      mJavaFunctor.Call( returnValue, data);
+    }
+
+    bool IsFunction( const v8::Local& function)
+    {
+      return mJavaFunctor.IsFunction(function);
+    }
+
+    void SetEmitInterface( EmitNotificationInterface* interface)
+    {
+      mJavaFunctor.SetEmitInterface( interface );
+    }
+    virtual ~BaseCallBack() {}
+
+    std::string mSignalName;
+    BaseJavaScriptCallback mJavaFunctor;
+};
+
+namespace
+{
+
+class ActorCallback :  public BaseCallBack
+{
+public:
+
+  ActorCallback(v8::Isolate* isolate,  const v8::Local& callback ,const std::string& signalName )
+  : BaseCallBack( isolate, callback, signalName )
+  {
+  }
+  bool OnTouch( Actor actor, const TouchEvent& event)
+  {
+    std::vector< Dali::Any > arguments;  // Dali::Vector considers Dali::Any to be a non trivial type so won't compile
+    Dali::Any returnValue(false);
+    arguments.push_back( actor );
+    arguments.push_back( event );
+    CallJavaScript( returnValue, arguments );
+    bool ret;
+    returnValue.Get(ret);
+    return ret;
+  }
+  bool OnHover( Actor actor, const HoverEvent& event)
+  {
+    std::vector< Dali::Any > arguments;  // Dali::Vector considers Dali::Any to be a non trivial type so won't compile
+    Dali::Any returnValue(false);
+    arguments.push_back( actor );
+    arguments.push_back( event );
+    CallJavaScript( returnValue, arguments );
+    bool ret;
+    returnValue.Get(ret);
+    return ret;
+  }
+  bool OnMouseWheel( Actor actor, const MouseWheelEvent& event)
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue(false);
+    arguments.push_back( actor );
+    arguments.push_back( event );
+    CallJavaScript( returnValue, arguments );
+    bool ret;
+    returnValue.Get(ret);
+    return ret;
+  }
+  void OnStage( Actor actor)
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;          //no return
+    arguments.push_back( actor );
+    CallJavaScript( returnValue, arguments );
+  }
+  void OffStage( Actor actor)
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;          //no return
+    arguments.push_back( actor );
+    CallJavaScript( returnValue, arguments );
+  }
+
+private:
+
+};
+
+
+class AnimationCallback :  public BaseCallBack
+{
+public:
+
+  AnimationCallback(v8::Isolate* isolate,  const v8::Local& callback ,const std::string& signalName )
+  : BaseCallBack( isolate, callback, signalName )
+  {
+  }
+  void Finished( Animation& animation)
+  {
+    std::vector< Dali::Any > arguments;  // Dali::Vector considers Dali::Any to be a non trivial type so won't compile
+    Dali::Any returnValue;    //no return
+    arguments.push_back( animation );
+    CallJavaScript( returnValue, arguments );
+  }
+};
+
+
+class ImageCallback :  public BaseCallBack
+{
+public:
+
+  ImageCallback(v8::Isolate* isolate,  const v8::Local& callback ,const std::string& signalName )
+  : BaseCallBack( isolate, callback, signalName )
+  {
+  }
+  void LoadingFinished( ResourceImage image)
+  {
+    std::vector< Dali::Any > arguments;  // Dali::Vector considers Dali::Any to be a non trivial type so won't compile
+    Dali::Any returnValue;  //no return
+    arguments.push_back( image );
+    CallJavaScript( returnValue, arguments );
+  }
+};
+class StageCallback :  public BaseCallBack
+{
+public:
+
+  StageCallback(v8::Isolate* isolate,  const v8::Local& callback ,const std::string& signalName )
+  : BaseCallBack( isolate, callback, signalName )
+  {
+  }
+
+  void KeyEventSignal( const KeyEvent& keyEvent )
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;  //no return
+    arguments.push_back( keyEvent );
+    CallJavaScript( returnValue, arguments );
+  }
+  void EventProcessingFinishedSignal()
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;  //no return
+    CallJavaScript( returnValue, arguments );
+  }
+  void TouchedSignal( const TouchEvent& touchEvent)
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;   //no return
+    arguments.push_back( touchEvent );
+    CallJavaScript( returnValue, arguments );
+  }
+};
+
+class KeyboardFocusCallback :  public BaseCallBack
+{
+public:
+
+  KeyboardFocusCallback(v8::Isolate* isolate,  const v8::Local& callback ,const std::string& signalName )
+  : BaseCallBack( isolate, callback, signalName )
+  {
+  }
+
+  Actor PreFocusChangeSignal(Actor currentFocusedActor,
+                             Actor proposedActorToFocus,
+                             Toolkit::Control::KeyboardFocusNavigationDirection direction  )
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue = Actor();  // we want an actor as a return value
+
+    arguments.push_back( currentFocusedActor );
+    arguments.push_back( proposedActorToFocus );
+
+    std::string name = KeyboardFocusManagerWrapper::GetDirectionName( direction );
+    arguments.push_back( name );
+
+    CallJavaScript( returnValue, arguments );
+
+    Actor ret;
+    returnValue.Get(ret);
+    return ret;
+  }
+  void FocusChangedSignal(Actor originalFocusedActor, Actor currentFocusedActor)
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;  //no return
+    arguments.push_back( originalFocusedActor );
+    arguments.push_back( currentFocusedActor );
+    CallJavaScript( returnValue, arguments );
+  }
+  void FocusGroupSignal( Actor currentFocusedActor, bool forward )
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;   //no return
+    arguments.push_back( currentFocusedActor );
+    arguments.push_back( forward );
+    CallJavaScript( returnValue, arguments );
+  }
+  void FocusedActorSignal( Actor activatedActor )
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;   //no return
+    arguments.push_back( activatedActor );
+    CallJavaScript( returnValue, arguments );
+  }
+};
+
+class PanGestureDetectorCallback :  public BaseCallBack
+{
+public:
+
+  PanGestureDetectorCallback(v8::Isolate* isolate,  const v8::Local& callback ,const std::string& signalName )
+  : BaseCallBack( isolate, callback, signalName )
+  {
+  }
+  void OnPan( Actor actor, const PanGesture& panGesture)
+  {
+    std::vector< Dali::Any > arguments;
+    Dali::Any returnValue;    //no return
+    arguments.push_back( actor );
+    arguments.push_back( panGesture );
+    CallJavaScript( returnValue, arguments );
+  }
+};
+
+void ActorConnection( v8::Isolate* isolate,
+                                     v8::Local javaScriptCallback,
+                                     ActorWrapper* actorWrapper,
+                                     const std::string& signalName,
+                                     Actor actor )
+{
+  bool connected(true);
+
+  ActorCallback* callback =new ActorCallback( isolate, javaScriptCallback, signalName );
+
+  if( strcmp( signalName.c_str(), SIGNAL_TOUCHED ) == 0 )
+  {
+    actor.TouchedSignal().Connect( callback, &ActorCallback::OnTouch );
+  }
+  else if( strcmp( signalName.c_str(), SIGNAL_HOVERED ) == 0 )
+  {
+    actor.HoveredSignal().Connect( callback, &ActorCallback::OnHover );
+  }
+  else if ( strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) == 0 )
+  {
+    actor.MouseWheelEventSignal().Connect( callback, &ActorCallback::OnMouseWheel );
+  }
+  else if ( strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) == 0 )
+  {
+    actor.OnStageSignal().Connect( callback, &ActorCallback::OnStage);
+  }
+  else if ( strcmp( signalName.c_str(), SIGNAL_OFF_STAGE ) == 0 )
+  {
+    actor.OffStageSignal().Connect( callback, &ActorCallback::OffStage);
+  }
+  else
+  {
+    connected = false;
+  }
+
+  if( connected )
+  {
+    actorWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+  else
+  {
+    delete callback;
+  }
+}
+
+void AnimationConnection( v8::Isolate* isolate,
+                                     v8::Local javaScriptCallback,
+                                     AnimationWrapper* animWrapper,
+                                     const std::string& signalName,
+                                     Animation anim )
+{
+  if( signalName ==  ANIMATION_SIGNAL_FINISHED)
+  {
+    AnimationCallback* callback =new AnimationCallback( isolate, javaScriptCallback, signalName );
+    anim.FinishedSignal().Connect( callback, &AnimationCallback::Finished );
+    animWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+}
+
+void ImageConnection( v8::Isolate* isolate,
+                                     v8::Local javaScriptCallback,
+                                     ImageWrapper* imageWrapper,
+                                     const std::string& signalName,
+                                     Image image)
+{
+  // Nine patch will downcast to ResourceImage
+  ResourceImage resourceImage( ResourceImage::DownCast( image ) );
+  if( !resourceImage )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "can only connect to Resource / NinePatch Images");
+    return;
+  }
+
+  if( strcmp( signalName.c_str(), SIGNAL_IMAGE_LOADING_FINISHED ) == 0 )
+  {
+    ImageCallback* callback =new ImageCallback( isolate, javaScriptCallback, signalName );
+
+    resourceImage.LoadingFinishedSignal().Connect( callback, &ImageCallback::LoadingFinished );
+    imageWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+  else if ( strcmp( signalName.c_str() , SIGNAL_IMAGE_UPLOADED ) == 0 )
+  {
+    ImageCallback* callback =new ImageCallback( isolate, javaScriptCallback, signalName );
+    resourceImage.LoadingFinishedSignal().Connect( callback, &ImageCallback::LoadingFinished );
+    imageWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+}
+
+void StageConnection( v8::Isolate* isolate,
+                                     v8::Local javaScriptCallback,
+                                     StageWrapper* stageWrapper,
+                                     const std::string& signalName,
+                                     Stage stage)
+{
+  bool connected( true );
+  StageCallback* callback =new StageCallback( isolate, javaScriptCallback, signalName );
+
+  if( strcmp( signalName.c_str() ,STAGE_SIGNAL_KEY_EVENT) == 0 )
+  {
+    stage.KeyEventSignal().Connect( callback, &StageCallback::KeyEventSignal );
+   }
+  else if ( strcmp( signalName.c_str(),  STAGE_SIGNAL_EVENT_PROCESSING_FINISHED ) == 0)
+  {
+    stage.EventProcessingFinishedSignal().Connect( callback, &StageCallback::EventProcessingFinishedSignal );
+  }
+  else if (strcmp( signalName.c_str(), STAGE_SIGNAL_TOUCHED ) == 0 )
+  {
+    stage.TouchedSignal().Connect( callback, &StageCallback::TouchedSignal );
+  }
+  else
+  {
+    connected = false;
+  }
+
+  if( connected )
+  {
+    stageWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+  else
+  {
+    delete  callback;
+  }
+}
+
+void KeyboardFocusManagerConnection( v8::Isolate* isolate,
+      v8::Local javaScriptCallback,
+      KeyboardFocusManagerWrapper* keyboardFocusWrapper,
+      const std::string& signalName,
+      Toolkit::KeyboardFocusManager keyboardFocusManager)
+{
+  bool connected( true );
+  KeyboardFocusCallback* callback =new KeyboardFocusCallback( isolate, javaScriptCallback, signalName );
+
+  if( strcmp( signalName.c_str(), KEYBOARD_FOCUS_MANAGER_SIGNAL_PRE_FOCUS_CHANGE ) == 0 )
+  {
+    keyboardFocusManager.PreFocusChangeSignal().Connect( callback, &KeyboardFocusCallback::PreFocusChangeSignal );
+  }
+  else if ( strcmp( signalName.c_str(),  KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_CHANGED ) == 0 )
+  {
+    keyboardFocusManager.FocusChangedSignal().Connect( callback, &KeyboardFocusCallback::FocusChangedSignal );
+  }
+  else if ( strcmp( signalName.c_str(), KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_GROUP_CHANGED ) == 0 )
+  {
+    keyboardFocusManager.FocusGroupChangedSignal().Connect( callback, &KeyboardFocusCallback::FocusGroupSignal );
+  }
+  else if ( strcmp( signalName.c_str(), KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUSED_ACTOR_ACTIVATED ) == 0 )
+  {
+    keyboardFocusManager.FocusedActorActivatedSignal().Connect( callback, &KeyboardFocusCallback::FocusedActorSignal );
+  }
+  else
+  {
+    connected = false;
+  }
+
+  if( connected )
+  {
+    keyboardFocusWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+  else
+  {
+    delete  callback;
+  }
+}
+
+void PanGestureDetectorConnection( v8::Isolate* isolate,
+                                     v8::Local javaScriptCallback,
+                                     PanGestureDetectorWrapper* panGestureDetectorWrapper,
+                                     const std::string& signalName,
+                                     PanGestureDetector panGestureDetector )
+{
+  if( strcmp( signalName.c_str() , SIGNAL_PAN_DETECTED ) == 0 )
+  {
+    PanGestureDetectorCallback* callback =new PanGestureDetectorCallback( isolate, javaScriptCallback, signalName );
+    panGestureDetector.DetectedSignal().Connect( callback, &PanGestureDetectorCallback::OnPan );
+    panGestureDetectorWrapper->GetSignalManager()->AddCallback( static_cast(callback) );
+  }
+}
+
+} // un-named namespace
+
+
+SignalManager::SignalManager()
+:mInsideCallback(false)
+{
+
+}
+SignalManager::~SignalManager()
+{
+  // the object owning the signal manager ( e.g. an actor wrapper ) has been deleted
+  // delete the callbacks objects
+  for( CallBackContainer::Iterator iter = mCallbacks.Begin(); iter != mCallbacks.End(); ++iter )
+  {
+      BaseCallBack* callback = (*iter);
+      delete callback;
+  }
+  for( CallBackContainer::Iterator iter = mDisconnectedCallbacks.Begin(); iter != mDisconnectedCallbacks.End(); ++iter )
+  {
+    BaseCallBack* callback = (*iter);
+    delete callback;
+  }
+}
+
+
+void SignalManager::SignalConnect( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  // format is
+  // first paramter =  signal to connect to
+  // Second parameter = function ( to run )
+  // args.This() = myActor
+  // e.g. myActor.Connect("touched", myJavaScriptActorTouched );
+
+  // Inside Callback on myJavaScriptActorTouched
+  // myActor.Disconnect("touched", myJavaScriptActorTouched );
+
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  if( !args[1]->IsFunction() )
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "function parameter not found ");
+    return;
+  }
+
+  // get the function
+  v8::Local func =v8::Handle::Cast(args[1]);
+
+  // get the handle wrapper
+  BaseWrappedObject* baseObject = BaseWrappedObject::UnWrap( isolate, args.This() );
+
+  // First paramter = signal name as a string
+  bool found( false );
+  std::string signal = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "signal name parameter not found ");
+    return;
+  }
+
+  if( signal.empty() || ( signal.length() > MAX_SIGNAL_NAME_LENGTH ) )
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "signal name length out of range");
+    return;
+  }
+  // We need to determine what type of function needs to be hooked
+  // see if we're connecting to an Actor
+  switch( baseObject->GetType() )
+  {
+  case BaseWrappedObject::ACTOR:
+  {
+    ActorWrapper* actorWrapper = static_cast< ActorWrapper*>( baseObject );
+    ActorConnection( isolate, func, actorWrapper, signal,  actorWrapper->GetActor() );
+    break;
+  }
+  case BaseWrappedObject::ANIMATION:
+  {
+    AnimationWrapper* animWrapper = static_cast< AnimationWrapper*>( baseObject );
+    AnimationConnection( isolate, func, animWrapper, signal, animWrapper->GetAnimation() );
+    break;
+  }
+  case BaseWrappedObject::IMAGE:
+  {
+    ImageWrapper* imageWrapper = static_cast< ImageWrapper*>( baseObject );
+    ImageConnection( isolate, func, imageWrapper, signal, imageWrapper->GetImage() );
+    break;
+  }
+  case BaseWrappedObject::STAGE:
+  {
+    StageWrapper* stageWrapper = static_cast< StageWrapper*>( baseObject );
+    StageConnection( isolate, func, stageWrapper, signal, stageWrapper->GetStage() );
+    break;
+  }
+  case BaseWrappedObject::KEYBOARD_FOCUS_MANAGER:
+  {
+    KeyboardFocusManagerWrapper* keyboardFocusWrapper = static_cast< KeyboardFocusManagerWrapper*>( baseObject );
+    KeyboardFocusManagerConnection( isolate, func, keyboardFocusWrapper, signal, keyboardFocusWrapper->GetKeyboardFocusManager() );
+    break;
+  }
+  case BaseWrappedObject::PAN_GESTURE_DETECTOR:
+  {
+    PanGestureDetectorWrapper* panGestureDetectorWrapper = static_cast< PanGestureDetectorWrapper*>( baseObject );
+    PanGestureDetectorConnection( isolate, func, panGestureDetectorWrapper, signal, panGestureDetectorWrapper->GetPanGestureDetector() );
+    break;
+  }
+  default:
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "object does not support connections");
+    break;
+  }
+  }
+
+}
+
+void SignalManager::SignalDisconnect( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  // we can get the function name.... use that to disconnect from the object
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  if( !args[1]->IsFunction() )
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "function parameter not found ");
+    return;
+  }
+
+  // get the function
+  v8::Local func =v8::Handle::Cast(args[1]);
+
+  // get the handle wrapper
+  BaseWrappedObject* baseObject = BaseWrappedObject::UnWrap( isolate, args.This() );
+
+  // First parameter = signal name as a string
+  bool found( false );
+  std::string signal = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "signal name parameter not found ");
+    return;
+  }
+
+  SignalManager* signalManager = baseObject->GetSignalManager();
+  if(signalManager )
+  {
+    signalManager->RemoveCallback( isolate, signal, func);
+  }
+
+
+}
+void SignalManager::AddCallback( BaseCallBack* callback )
+{
+  // used by the callback to inform signal manager when it is being triggered.
+   callback->SetEmitInterface( this );
+
+   mCallbacks.PushBack( callback );
+}
+void SignalManager::RemoveCallback( v8::Isolate* isolate, const std::string& signalName, const v8::Local& function )
+{
+  // lets disconnect
+  for( CallBackContainer::Iterator iter = mCallbacks.Begin(); iter != mCallbacks.End(); ++iter )
+  {
+    BaseCallBack* callback = (*iter);
+    if( ( callback->mSignalName == signalName ) &&
+        ( callback->IsFunction(  function  )  )  )
+    {
+      mCallbacks.Erase( iter );
+
+      // if we're inside a callback::Call function, then deleting it will cause a seg fault
+      if( mInsideCallback )
+      {
+        callback->DisconnectAll();
+        mDisconnectedCallbacks.PushBack( callback );
+      }
+      else
+      {
+        delete callback;
+      }
+      return;
+    }
+  }
+}
+
+void SignalManager::CallbackEnter()
+{
+  mInsideCallback = true;
+}
+
+void SignalManager::CallbackExit()
+{
+  // this gets called when we've finished calling into JavaScript, e.g. as a result of animation finishing
+  // which is being listened to by a javascript function.
+
+  // it possible that inside the JavaScript call, it tries to disconnect.
+  // If this happens the callback is added to the mDisconnectedCallbacks list.
+  // We then delay deleting of the callback object until the JavaScript call has finished in this function.
+
+  mInsideCallback = false;
+
+  // lets delete any call backs that were disconnect during the JavaScript call
+  for( CallBackContainer::Iterator iter = mDisconnectedCallbacks.Begin(); iter != mDisconnectedCallbacks.End(); ++iter )
+  {
+    BaseCallBack* callback = (*iter);
+    delete callback;
+  }
+  mDisconnectedCallbacks.Clear();
+
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/signals/signal-manager.h b/plugins/dali-script-v8/src/signals/signal-manager.h
new file mode 100644
index 0000000..cf09569
--- /dev/null
+++ b/plugins/dali-script-v8/src/signals/signal-manager.h
@@ -0,0 +1,143 @@
+#ifndef __DALI_V8PLUGIN_SIGNAL_MANAGER_H__
+#define __DALI_V8PLUGIN_SIGNAL_MANAGER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+class BaseCallBack;
+class HandleWrapper;
+
+/**
+ * Manages signal connection / disconnection.
+ *
+ * How it works...
+ * 1) SignalConnect, SignalDisconnect is installed on to a dali-wrapped object template. E.g.
+ *
+ *   objTemplate->Set( v8::String::NewFromUtf8( isolate, "Connect"),
+                     v8::FunctionTemplate::New( isolate, SignalManager::SignalConnect) );
+ *
+ * 2) When the  actor.Connect(...) is called, v8 runs SignalManager::SignalConnect( args )
+ *
+ * args.This() == Dali object ( e.g. Actor / Animation / Image ).
+ * args[ 0 ] == Signal name, e.g. "touched"
+ * args[ 1 ] ==  JavaScript function to run when the signal is fired.
+ *
+ * 3) SignalManager uses the signal name, to decide what type of Dali Signal is required.
+ * It then creates a C++ object which can be connected to the Signal.
+ * That object also holds a pointer to the JavaScript callback function
+ *
+ * 4) When the signal is fired, it triggers the signal in the C++ object, which then fires
+ * the JavaScript function. See ActorCallback::OnTouch
+ *
+ *  When the object that holds SignalManager dies (e.g. an ActorWrapper), the signal manager for that
+ *  object is destroyed, which automatically disconnects any signal connections.
+ *
+ *  @TODO
+ *  Currently DALi Core supports 'DoConnectSignal' which passes in no parameters and expects no return value.
+ *  If we could extend this, so DoConnect supports a generic function such as
+ *  Dali::Any (*CallbackFunction) (Dali::Vector< Dali::Any > parameters );
+ *  then we should be able to remove most of the code in this file.
+ *  As this is how BaseJavaScriptCallback::Call() in SignalManager.cpp works.
+ *
+ *
+ *
+ */
+class SignalManager : public EmitNotificationInterface
+{
+public:
+
+  /**
+   * Constructor
+   */
+  SignalManager();
+
+  /**
+   * Destructor
+   */
+  virtual ~SignalManager();
+
+  /**
+   * signal connect function, installed on dali-wrapped object
+   */
+  static void SignalConnect( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * signal disconnect function, installed on dali-wrapped object
+   */
+  static void SignalDisconnect( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Add a callback
+   * @param[in] callback
+   */
+  void AddCallback( BaseCallBack* callback );
+
+  /**
+   * Remove a callback
+   * @param[in] signalName name
+   * @param[in] function to remove
+   */
+  void RemoveCallback( v8::Isolate* isolate, const std::string& signalName, const v8::Local& function );
+
+private:
+
+public:
+
+  /**
+   * @copydoc EmitNotificationInterface::CallbackEnter()
+   */
+  virtual void CallbackEnter();
+
+  /**
+   * @copydoc EmitNotificationInterface::CallbackExit()
+   */
+  virtual void CallbackExit();
+
+
+  // typically an object will only have 1 callback, so a vector is ok, e.g.
+  // there's no point in storing a map of callbacks for an actor that will only have 1 connection
+  // for OnTouch.
+  typedef Dali::Vector< BaseCallBack* > CallBackContainer;
+
+  CallBackContainer mCallbacks;               ///< List of callbacks
+  CallBackContainer mDisconnectedCallbacks;   ///< List of disconnected callbacks
+  bool mInsideCallback;                       ///< To prevent recursive loops
+
+};
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header
diff --git a/plugins/dali-script-v8/src/stage/stage-api.cpp b/plugins/dali-script-v8/src/stage/stage-api.cpp
new file mode 100644
index 0000000..cdeb06b
--- /dev/null
+++ b/plugins/dali-script-v8/src/stage/stage-api.cpp
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "stage-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/***************************************
+ * STAGE FUNCTIONS
+ *
+ ****************************************/
+Dali::Stage StageApi::GetStage(v8::Isolate* isolate, const v8::FunctionCallbackInfo& args)
+{
+  // the stage object should be in args, but for now just use GetCurrent
+  return Stage::GetCurrent();
+}
+
+/**
+ * Adds a child Actor to the Stage.
+ * @method add
+ * @for Stage
+ * @param {Object} Actor
+ */
+void StageApi::Add( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+  bool found( false );
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    stage.Add( actor );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing actor parameter");
+  }
+}
+
+/**
+ * Removes a child Actor to the Stage.
+ * @method remove
+ * @for Stage
+ * @param {Object} Actor
+ */
+void StageApi::Remove( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+  bool found( false );
+
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( found )
+  {
+    stage.Remove( actor );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing actor parameter");
+  }
+}
+/**
+ * Get the size of the stage
+ * @method getSize
+ * @for Stage
+ * @return {Object} size with properties { x: , y: }
+ */
+void StageApi::GetSize( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+  Vector2 size( stage.GetSize() );
+
+  v8::Local sizeObject = v8::Object::New( isolate );
+  sizeObject->Set( v8::String::NewFromUtf8( isolate, "x"), v8::Number::New( isolate,size.width ));
+  sizeObject->Set( v8::String::NewFromUtf8( isolate, "y"), v8::Number::New( isolate,size.height ));
+
+  // set return value
+  args.GetReturnValue().Set( sizeObject );
+
+}
+/**
+ * Retrieve the list of render-tasks.
+ * @method getRenderTaskList
+ * @for Stage
+ * @return {Object} render task list
+ */
+void StageApi::GetRenderTaskList( const v8::FunctionCallbackInfo< v8::Value >& args  )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+
+  RenderTaskList taskList = stage.GetRenderTaskList();
+
+  v8::Local  object = RenderTaskListWrapper::WrapRenderTaskList( isolate, taskList );
+
+  args.GetReturnValue().Set(  object );
+}
+/**
+ * Query the number of on-stage layers.
+ * Note that a default layer is always provided (count >= 1).
+ * @method getLayerCount
+ * @for Stage
+ * @return {Number} number of layers
+ */
+void StageApi::GetLayerCount( const v8::FunctionCallbackInfo& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, stage.GetLayerCount() ) );
+
+}
+/**
+ * Retrieve the list of render-tasks.
+ * @method getLayer
+ * @for Stage
+ * @param {Integer} depth
+ * @return {Object} layer
+ */
+void StageApi::GetLayer( const v8::FunctionCallbackInfo< v8::Value >& args  )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+
+  bool found( false );
+  unsigned int depth = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Integer parameter missing" );
+    return;
+  }
+  Layer rootLayer = stage.GetLayer( depth );
+
+  v8::Handle < v8::Object > wrappedLayer = ActorWrapper::WrapActor( isolate, rootLayer );
+  args.GetReturnValue().Set( wrappedLayer );
+}
+/**
+ * Returns the Stage's Root Layer.
+ * @method getRootLayer
+ * @for Stage
+ * @return {Object} root layer
+ */
+void StageApi::GetRootLayer( const v8::FunctionCallbackInfo& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+
+  Layer rootLayer = stage.GetRootLayer();
+
+  v8::Handle < v8::Object > wrappedLayer = ActorWrapper::WrapActor( isolate, rootLayer );
+  args.GetReturnValue().Set( wrappedLayer );
+}
+
+/**
+ * Set the background color of the stage
+ * @method setBackgroundColor
+ * @for Stage
+ * @param {Object} Array of [Red,Green,Blue,Alpha], e.g. dali.COLOR_RED, or [1,0,0,1] (full red and alpha);
+ * @example
+ *     dali.stage.setBackgroundColor( dali.COLOR_RED );
+ *
+ *     dali.stage.setBackgroundColor( [0.5,0.5,0.5,1 ] ); // set the background to grey
+ */
+void StageApi::SetBackgroundColor( const v8::FunctionCallbackInfo& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+  bool found( false );
+
+  Vector4 backgroundColor = V8Utils::GetVector4Parameter( PARAMETER_0, found, isolate, args);
+  if (!found)
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "no parameter not found" );
+    return;
+  }
+  stage.SetBackgroundColor( backgroundColor );
+}
+/**
+ * Get the background color of the stage
+ * @method getBackgroundColor
+ * @for Stage
+ * @return {Object} object that contains the properties [red:,green:,blue,alpha:]
+ */
+void StageApi::GetBackgroundColor( const v8::FunctionCallbackInfo& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+
+  Vector4 color = stage.GetBackgroundColor();
+
+  v8::Local colorObject = v8::Object::New( isolate );
+
+  colorObject->Set( v8::String::NewFromUtf8( isolate, "red"),   v8::Number::New( isolate,color.r));
+  colorObject->Set( v8::String::NewFromUtf8( isolate, "green"), v8::Number::New( isolate,color.g));
+  colorObject->Set( v8::String::NewFromUtf8( isolate, "blue"),  v8::Number::New( isolate,color.b));
+  colorObject->Set( v8::String::NewFromUtf8( isolate, "alpha"), v8::Number::New( isolate,color.a));
+
+  // set return value
+  args.GetReturnValue().Set( colorObject );
+
+
+}
+/**
+ * Retrieve the DPI of the display device to which the stage is connected.
+ * @method getDpi
+ * @for Stage
+ * @return {Object} object that contains the properties [x:,y:]
+ */
+void StageApi::GetDpi( const v8::FunctionCallbackInfo& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Stage stage = GetStage( isolate, args );
+
+  Vector2 dpi( stage.GetDpi() );
+
+  v8::Local dpiObject = v8::Object::New( isolate );
+  dpiObject->Set( v8::String::NewFromUtf8( isolate, "x"),   v8::Number::New( isolate,dpi.x));
+  dpiObject->Set( v8::String::NewFromUtf8( isolate, "y"), v8::Number::New( isolate,dpi.y));
+
+
+  args.GetReturnValue().Set(  dpiObject );
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/stage/stage-api.h b/plugins/dali-script-v8/src/stage/stage-api.h
new file mode 100644
index 0000000..8ace0e9
--- /dev/null
+++ b/plugins/dali-script-v8/src/stage/stage-api.h
@@ -0,0 +1,60 @@
+#ifndef __DALI_V8PLUGIN_STAGE_API_H__
+#define __DALI_V8PLUGIN_STAGE_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace StageApi
+{
+
+  /**
+   * helper
+   */
+  Dali::Stage GetStage( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * StageApi API see image-actor.h for a description
+    */
+  void Add( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void Remove( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetSize( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetRenderTaskList( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetLayer( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetLayerCount( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetRootLayer( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void SetBackgroundColor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetBackgroundColor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetDpi( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace StageApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_STAGE_API_H__
diff --git a/plugins/dali-script-v8/src/stage/stage-wrapper.cpp b/plugins/dali-script-v8/src/stage/stage-wrapper.cpp
new file mode 100644
index 0000000..b9005c8
--- /dev/null
+++ b/plugins/dali-script-v8/src/stage/stage-wrapper.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "stage-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace
+{
+
+/**
+ * Contains a list of all functions that can be called on the stage
+ */
+const ApiFunction StageFunctionTable[]=
+{
+    /**************************************
+    * Stage API (in order of stage.h)
+    * Any properties that have accessor functions are ignored to avoid duplication
+    **************************************/
+    { "Add",                  StageApi::Add       },
+    { "Remove",               StageApi::Remove    },
+    { "GetSize",              StageApi::GetSize   },
+    { "GetRenderTaskList",    StageApi::GetRenderTaskList   },
+    { "GetLayerCount",        StageApi::GetLayerCount   },
+    { "GetLayer",             StageApi::GetLayer        },
+    { "GetRootLayer",         StageApi::GetRootLayer   },
+    { "SetBackgroundColor",   StageApi::SetBackgroundColor   },
+    { "GetBackgroundColor",   StageApi::GetBackgroundColor   },
+    { "GetDpi",               StageApi::GetDpi       },
+};
+
+const unsigned int StageFunctionTableCount = sizeof(StageFunctionTable)/sizeof(StageFunctionTable[0]);
+} //un-named space
+
+
+StageWrapper::StageWrapper( const Dali::Stage& stage, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::STAGE , gc )
+{
+    mStage = stage;
+}
+
+v8::Handle StageWrapper::WrapStage(v8::Isolate* isolate, const Dali::Stage& stage )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetStageTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the Stage wrapper
+  StageWrapper* pointer =  new StageWrapper( stage, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local StageWrapper::GetStageTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+  objectTemplate = MakeStageTemplate( isolate );
+  return handleScope.Escape( objectTemplate );
+}
+
+v8::Handle StageWrapper::MakeStageTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  // add intercepts for Signals, we can't use HandleWrapper::AddIntercepts because Stage doesn't inherit
+  // from Handle ( just baseHandle)
+  ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, StageFunctionTable, StageFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+Stage StageWrapper::GetStage()
+{
+  return mStage;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/stage/stage-wrapper.h b/plugins/dali-script-v8/src/stage/stage-wrapper.h
new file mode 100644
index 0000000..50e5c6c
--- /dev/null
+++ b/plugins/dali-script-v8/src/stage/stage-wrapper.h
@@ -0,0 +1,77 @@
+#ifndef __DALI_V8PLUGIN_STAGE_WRAPPER_H__
+#define __DALI_V8PLUGIN_STAGE_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An Stage  wrapper.
+ * Provides access to Stage specific functionality and V8 memory handling.
+ */
+class DALI_INTERNAL StageWrapper : public BaseWrappedObject
+{
+
+public:
+
+  StageWrapper( const Stage& stage,
+                GarbageCollectorInterface& gc );
+
+  virtual ~StageWrapper() {};
+
+  /**
+   * Wraps a stage
+   */
+  static v8::Handle WrapStage(v8::Isolate* isolate, const Dali::Stage& );
+
+  Stage GetStage();
+
+  virtual SignalManager* GetSignalManager() { return &mSignalManager;}
+
+
+private:
+
+  // Stage
+  Stage mStage;
+  SignalManager mSignalManager;
+
+  static v8::Handle MakeStageTemplate( v8::Isolate* isolate );
+  static v8::Local GetStageTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_STAGE_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/text/font-api.cpp b/plugins/dali-script-v8/src/text/font-api.cpp
new file mode 100644
index 0000000..385f58d
--- /dev/null
+++ b/plugins/dali-script-v8/src/text/font-api.cpp
@@ -0,0 +1,458 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "font-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+
+
+
+} //un named namespace
+
+/***************************************
+ * IMAGE  FUNCTIONS
+ *
+ ****************************************/
+Font FontApi::GetFont( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  FontWrapper* wrapper = static_cast< FontWrapper *>(ptr);
+  return wrapper->GetFont();
+}
+Font FontApi::GetFont( v8::Isolate* isolate, v8::Local& value )
+{
+  v8::HandleScope handleScope( isolate );
+  v8::Local object = value->ToObject();
+  v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+  void* ptr = field->Value();
+
+  FontWrapper* wrapper = static_cast< FontWrapper *>(ptr);
+  return wrapper->GetFont();
+}
+
+struct FontParams
+{
+  typedef enum
+  {
+    NO_SIZE_SET,
+    USE_POINT_SIZE,
+    USE_PIXEL_SIZE,
+    USE_CAP_SIZE,
+  } SizeType;
+
+
+  FontParams()
+  :pointSize( 0 ),
+   pixelSize( 0 ),
+   capsSize( 0 ),
+   sizeType( FontParams::NO_SIZE_SET )
+  {
+  }
+
+  std::string family;
+  std::string style;
+  PointSize pointSize;
+  PixelSize pixelSize;
+  CapsHeight capsSize;
+  SizeType sizeType;
+
+
+};
+
+
+void ReadFontParameters( v8::Isolate* isolate,
+                         v8::Local options,
+                         FontParams& fontParams )
+{
+  // foont options is an optional parameter passed in which holds
+  // optional settings
+  // var fontOptions = {
+  //  family: "arial",
+  //  style:  "bold",
+  //  // one of the following
+  //  pixelSize: xx
+  //  pointSize: xx
+  //  capsHeight:xx // height of a capital letter above the baseline for a particular typeface.
+  //
+  // };
+  v8::HandleScope handleScope( isolate );
+  if( !options->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 ( font parameters)" );
+    return;
+  }
+  v8::Local obj = options->ToObject();
+
+  v8::Local familyValue = obj->Get( v8::String::NewFromUtf8( isolate, "family" ) );
+  if( familyValue->IsString() )
+  {
+    fontParams.family =   V8Utils::v8StringToStdString( familyValue );
+  }
+
+  v8::Local styleValue = obj->Get( v8::String::NewFromUtf8( isolate, "style" ) );
+  if( styleValue->IsString() )
+  {
+    fontParams.style =   V8Utils::v8StringToStdString( styleValue );
+  }
+
+  v8::Local pixelSize = obj->Get( v8::String::NewFromUtf8( isolate, "pixelSize" ) );
+  v8::Local pointSize = obj->Get( v8::String::NewFromUtf8( isolate, "pointSize" ) );
+  v8::Local capsHeight = obj->Get( v8::String::NewFromUtf8( isolate, "capsHeight" ) );
+
+  if( pixelSize->IsUint32() )
+  {
+    fontParams.pixelSize.value =   pixelSize->ToUint32()->Value();
+    fontParams.sizeType = FontParams::USE_PIXEL_SIZE;
+  }
+  else if( pointSize->IsUint32() )
+  {
+    fontParams.pointSize.value =   pointSize->ToUint32()->Value();
+    fontParams.sizeType = FontParams::USE_POINT_SIZE;
+  }
+  else if( capsHeight->IsUint32() )
+  {
+    fontParams.capsSize.value = capsHeight->ToUint32()->Value();
+    fontParams.sizeType = FontParams::USE_CAP_SIZE;
+  }
+
+}
+
+Font FontApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  // if no parameters just create a default font
+  if ( args.Length() == 0)
+  {
+    return Font::New();
+  }
+  FontParams params;
+
+  ReadFontParameters( isolate, args[0], params );
+
+  FontParameters fontParams;
+  // construct a dali font parameters object
+  switch( params.sizeType)
+  {
+    case  FontParams::USE_PIXEL_SIZE:
+    {
+      fontParams = FontParameters( params.family, params.style, params.pixelSize  );
+      break;
+    }
+    case  FontParams::USE_POINT_SIZE:
+    {
+      fontParams = FontParameters( params.family, params.style, params.pointSize  );
+      break;
+    }
+    case  FontParams::USE_CAP_SIZE:
+    {
+      fontParams = FontParameters( params.family, params.style, params.capsSize  );
+      break;
+    }
+    default:
+    {
+      fontParams = FontParameters( params.family, params.style, PointSize(0.f));
+      break;
+    }
+  }
+  return Font::New( fontParams );
+
+}
+
+
+void FontApi::GetFamilyForText( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+
+  bool foundString;
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, foundString, isolate, args );
+  if( !foundString )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 ( text )" );
+    return;
+  }
+  std::string family = Font::GetFamilyForText( text );
+
+  args.GetReturnValue().Set( v8::String::NewFromUtf8( isolate, family.c_str()) );
+
+}
+void FontApi::GetLineHeightFromCapsHeight( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  FontParams params;
+  ReadFontParameters( isolate, args[0], params );
+  if( params.sizeType != FontParams::USE_CAP_SIZE )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "caps height not found" );
+    return;
+  }
+
+  PixelSize size = Font::GetLineHeightFromCapsHeight( params.family, params.style, params.capsSize);
+  args.GetReturnValue().Set( v8::Integer::New( isolate, size.value ) );
+}
+
+void FontApi::GetInstalledFonts( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found( false );
+  std::vector fontList;
+
+  std::string mode = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+
+  if( mode == "LIST_APPLICATION_FONTS" )
+  {
+    fontList = Font::GetInstalledFonts( Font::LIST_APPLICATION_FONTS );
+  }
+  else if( mode == "LIST_ALL_FONTS")
+  {
+    fontList = Font::GetInstalledFonts( Font::LIST_ALL_FONTS );
+  }
+  else  // default
+  {
+    fontList = Font::GetInstalledFonts( Font::LIST_SYSTEM_FONTS );
+  }
+  // create a javascript array
+  v8::Local array = v8::Array::New(isolate, fontList.size() );
+  for( std::size_t i = 0; i < fontList.size(); i++)
+  {
+    const char* fontName = fontList[i].c_str();
+    array->Set(v8::Integer::New(args.GetIsolate(), i), v8::String::NewFromUtf8( isolate,fontName));
+  }
+
+  args.GetReturnValue().Set( array );
+}
+
+void FontApi::MeasureTextWidth( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Font font = GetFont( isolate, args );
+
+  //float MeasureTextWidth(const std::string& text, float textHeightPx) const;
+
+  bool found( false );
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if(! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "text not found" );
+    return;
+  }
+  int height = V8Utils::GetIntegerParameter( PARAMETER_1, found, isolate, args, 0 );
+  if( !found )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "missing text height" );
+     return;
+  }
+  float width = font.MeasureTextWidth( text, height );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, width ) );
+
+}
+void FontApi::MeasureTextHeight( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Font font = GetFont( isolate, args );
+
+  //float MeasureTextHeight(const std::string& text, float textHeightPx) const;
+
+  bool found( false );
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if(! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "text not found" );
+    return;
+  }
+  int width= V8Utils::GetIntegerParameter( PARAMETER_1, found, isolate, args, 0 );
+  if( !found )
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "missing text height" );
+     return;
+  }
+  float height = font.MeasureTextHeight( text, width );
+
+  args.GetReturnValue().Set( v8::Integer::New( isolate, height ) );
+}
+void FontApi::MeasureText( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Font font = GetFont( isolate, args );
+
+  bool found( false );
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if(! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "text not found" );
+    return;
+  }
+
+  Vector3 vec3 = font.MeasureText( text );
+  Dali::Property::Value value( vec3 );
+  v8::Local  object = PropertyValueWrapper::WrapDaliProperty( isolate, value);
+  args.GetReturnValue().Set(  object );
+
+}
+void FontApi::AllGlyphsSupported( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Font font = GetFont( isolate, args );
+
+  bool found( false );
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+  if(! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "text not found" );
+    return;
+  }
+
+  bool supported = font.AllGlyphsSupported( text );
+  args.GetReturnValue().Set( v8::Boolean::New(  isolate, supported) );
+
+}
+
+// This one function is use to create a property map, instead of the many individual property
+// getters used by the C++ Dali API.
+// propertyMap
+// {
+//    name:
+//    style:
+//    pointSize:
+//    pixelSize:
+//    lineHeight:
+//    ascender:
+//    underlineThickness:
+//    underlinePosition:
+//    isDefaultSystemFont:
+//    isDefaultSystemSize:
+// }
+
+void FontApi::GetProperties( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Font font = GetFont( isolate, args );
+
+  v8::Local keyObject = v8::Object::New( isolate );
+
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "family" ), v8::String::NewFromUtf8( isolate, font.GetName().c_str() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "style" ), v8::String::NewFromUtf8( isolate, font.GetStyle().c_str() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "pointSize" ),  v8::Integer::New( isolate, font.GetPointSize() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "pixelSize" ),  v8::Integer::New( isolate, font.GetPixelSize() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "lineHeight" ),  v8::Integer::New( isolate, font.GetLineHeight() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "ascender" ),  v8::Integer::New( isolate, font.GetAscender() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "underlineThickness" ),  v8::Integer::New( isolate, font.GetUnderlineThickness() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "underlinePosition" ),  v8::Integer::New( isolate, font.GetUnderlinePosition()) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "isDefaultSystemFont" ),  v8::Boolean::New( isolate, font.IsDefaultSystemFont() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "isDefaultSystemSize" ),  v8::Boolean::New( isolate,  font.IsDefaultSystemSize() ) );
+
+  args.GetReturnValue().Set( keyObject );
+
+}
+
+void FontApi::GetMetrics( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Font font = GetFont( isolate, args );
+
+  bool found( false );
+  std::string text = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args );
+
+  if(! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "character not found" );
+    return;
+  }
+
+  Text textObject( text );
+
+  Font::Metrics metric = font.GetMetrics( textObject[0] );
+
+  v8::Local keyObject = v8::Object::New( isolate );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "advance" ), v8::Integer::New( isolate, metric.GetAdvance() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "bearing" ), v8::Integer::New( isolate, metric.GetBearing() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "width" ),   v8::Integer::New( isolate, metric.GetWidth() ) );
+  keyObject->Set( v8::String::NewFromUtf8( isolate, "height" ),  v8::Integer::New( isolate, metric.GetHeight() ) );
+
+  args.GetReturnValue().Set( keyObject );
+
+}
+
+
+void FontApi::PointsToPixels( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found(false);
+  int pointSize= V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+      DALI_SCRIPT_EXCEPTION( isolate, "missing pointSize" );
+      return;
+  }
+  args.GetReturnValue().Set( v8::Integer::New( isolate, Font::PointsToPixels(pointSize) ) );
+
+}
+void FontApi::PixelsToPoints( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found(false);
+  int pixelSize= V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 );
+  if( !found )
+  {
+      DALI_SCRIPT_EXCEPTION( isolate, "missing pixelSize" );
+      return;
+  }
+  args.GetReturnValue().Set( v8::Integer::New( isolate, Font::PixelsToPoints(pixelSize) ) );
+}
+
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/text/font-api.h b/plugins/dali-script-v8/src/text/font-api.h
new file mode 100644
index 0000000..129c240
--- /dev/null
+++ b/plugins/dali-script-v8/src/text/font-api.h
@@ -0,0 +1,68 @@
+#ifndef __DALI_V8PLUGIN_FONT_API_H__
+#define __DALI_V8PLUGIN_FONT_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace FontApi
+{
+  Font GetFont( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+  Font GetFont( v8::Isolate* isolate, v8::Local& value );
+
+  Font GetFontFromParams( int paramIndex,
+                            bool& found,
+                            v8::Isolate* isolate,
+                            const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Constructor
+   */
+  Font New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Font API see image.h for a description
+   */
+  void GetFamilyForText( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetLineHeightFromCapsHeight( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetInstalledFonts( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MeasureTextWidth( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MeasureTextHeight( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MeasureText( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AllGlyphsSupported( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetProperties( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetMetrics( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void PointsToPixels( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void PixelsToPoints( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace FontApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_FONT_API_H__
diff --git a/plugins/dali-script-v8/src/text/font-wrapper.cpp b/plugins/dali-script-v8/src/text/font-wrapper.cpp
new file mode 100644
index 0000000..9760f51
--- /dev/null
+++ b/plugins/dali-script-v8/src/text/font-wrapper.cpp
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "font-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un-named name space
+{
+
+/**
+ * Contains a list of all functions that can be called on the font object
+ */
+const ApiFunction FontFunctionTable[]=
+{
+    /**************************************
+    * Font API (in order of font.h)
+    **************************************/
+    { "MeasureTextWidth",               FontApi::MeasureTextWidth },
+    { "MeasureTextHeight",              FontApi::MeasureTextHeight },
+    { "MeasureText",                    FontApi::MeasureText },
+    { "AllGlyphsSupported",             FontApi::AllGlyphsSupported },
+    { "GetProperties",                  FontApi::GetProperties }, // replace all getters
+    { "GetMetrics",                     FontApi::GetMetrics },
+};
+
+const unsigned int FontFunctionTableCount = sizeof(FontFunctionTable)/sizeof(FontFunctionTable[0]);
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction StaticFontFunctionTable[]=
+{
+    /**************************************
+    * Static font functions, called without a font object
+    **************************************/
+    { "GetFamilyForText",               FontApi::GetFamilyForText },
+    { "GetLineHeightFromCapsHeight",    FontApi::GetLineHeightFromCapsHeight },
+    { "GetInstalledFonts",              FontApi::GetInstalledFonts },
+    { "PointsToPixels",                 FontApi::PointsToPixels },
+    { "PixelsToPoints",                 FontApi::PixelsToPoints },
+};
+
+const unsigned int StaticFontFunctionTableCount = sizeof(StaticFontFunctionTable)/sizeof(FontFunctionTable[0]);
+
+} //un-named space
+
+
+FontWrapper::FontWrapper( const Dali::Font& font, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::FONT , gc )
+{
+    mFont = font;
+}
+
+v8::Handle FontWrapper::WrapFont(v8::Isolate* isolate, const Dali::Font& font )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = MakeFontTemplate( isolate );
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the Font wrapper
+  FontWrapper* pointer =  new FontWrapper( font, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  printf("Created Font!\n");
+  return handleScope.Escape( localObject );
+}
+
+
+v8::Handle FontWrapper::MakeFontTemplate( v8::Isolate* isolate )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, FontFunctionTable, FontFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+}
+
+void FontWrapper::NewFont( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if(!args.IsConstructCall())
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Font constructor called without 'new'");
+    return;
+  }
+
+  // attribs can be passed by value
+  Dali::Font font = FontApi::New( args );
+  if( !font )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "bad font parameters\n");
+    return;
+  }
+
+  v8::Local localObject = WrapFont( isolate, font );
+  args.GetReturnValue().Set( localObject );
+}
+
+Font FontWrapper::GetFont()
+{
+  return mFont;
+}
+
+v8::Handle FontWrapper::GetStaticFontObject(v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+   // add our functions properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, StaticFontFunctionTable, StaticFontFunctionTableCount );
+
+  v8::Local localObject = objTemplate->NewInstance();
+
+  return handleScope.Escape( localObject );
+
+ }
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/text/font-wrapper.h b/plugins/dali-script-v8/src/text/font-wrapper.h
new file mode 100644
index 0000000..328416a
--- /dev/null
+++ b/plugins/dali-script-v8/src/text/font-wrapper.h
@@ -0,0 +1,78 @@
+#ifndef __DALI_V8PLUGIN_FONT_WRAPPER_H__
+#define __DALI_V8PLUGIN_FONT_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+
+/**
+ * An Font  wrapper.
+ * Provides access to Font specific functionality and V8 memory handling.
+ */
+class FontWrapper : public BaseWrappedObject
+{
+
+public:
+
+  FontWrapper( const Font& font,
+                GarbageCollectorInterface& gc );
+
+  virtual ~FontWrapper()
+  {
+  };
+
+  /**
+   * @brief Creates a new Font wrapped inside a Javascript Object.
+   * @note: the actor type ie 'FontFont' is expected to be the name of the callee function.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewFont( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps a font
+   */
+  static v8::Handle WrapFont(v8::Isolate* isolate, const Dali::Font& );
+
+  Font GetFont();
+
+  static v8::Handle GetStaticFontObject(v8::Isolate* isolate);
+
+private:
+
+  Font mFont;
+  static v8::Handle MakeFontTemplate( v8::Isolate* isolate );
+
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_FONT_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/toolkit/builder/builder-api.cpp b/plugins/dali-script-v8/src/toolkit/builder/builder-api.cpp
new file mode 100644
index 0000000..7feb259
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/builder/builder-api.cpp
@@ -0,0 +1,474 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "builder-api.h"
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+
+Dali::Toolkit::Builder GetBuilder( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::Local object = args.This();
+  v8::Local field = v8::Local::Cast( object->GetInternalField( 0 ) );
+  void* ptr = field->Value();
+
+  BuilderWrapper* wrapper = static_cast( ptr );
+  return wrapper->GetBuilder();
+}
+
+
+void GetMapAndString( v8::Isolate* isolate,
+                      std::string stringKey,
+                      std::string& stringValue,
+                      std::string mapKey,
+                      Dali::Property::Map& map,
+                      v8::Local object)
+{
+    v8::Local stringNameValue = object->Get( v8::String::NewFromUtf8( isolate, stringKey.c_str() ) );
+    if( !stringNameValue->IsString() )
+    {
+      std::string message = "missing field :"+stringKey;
+      DALI_SCRIPT_EXCEPTION( isolate,  message);
+      return;
+    }
+    stringValue = V8Utils::v8StringToStdString( stringNameValue );
+
+    // constants is optional
+
+    v8::Local constants = object->Get( v8::String::NewFromUtf8( isolate, mapKey.c_str() ) );
+    if( constants->IsObject() )
+    {
+      map = V8Utils::GetPropertyMapFromObject( isolate, constants->ToObject() );
+    }
+}
+
+
+} // un-named namespace
+
+
+Dali::Toolkit::Builder BuilderApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  return Dali::Toolkit::Builder::New();
+}
+
+void BuilderApi::LoadFromString( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  bool found(false);
+  std::string str = V8Utils::GetStringParameter( 0, found, isolate, args );
+  if( found )
+  {
+    builder.LoadFromString( str );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing string parameter");
+  }
+}
+
+void BuilderApi::LoadFromFile( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  bool found(false);
+  std::string fileName= V8Utils::GetStringParameter( 0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing string parameter");
+    return;
+  }
+
+  std::ifstream fileStream( fileName.c_str() );
+  if( !fileStream.is_open() )
+  {
+    std::string message = "failed to open JSON file" + fileName;
+    DALI_SCRIPT_EXCEPTION( isolate,  message );
+    return;
+  }
+
+  //single-pass input iterator that reads successive characters from the input stream
+  std::string json = std::string( (std::istreambuf_iterator< char >( fileStream )), std::istreambuf_iterator< char >() );
+
+  builder.LoadFromString( json );
+
+}
+
+void BuilderApi::AddConstants( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  bool found(false);
+  Dali::Property::Map map = V8Utils::GetPropertyMapParameter( 0,found, isolate, args );
+
+  if( found )
+  {
+    builder.AddConstants( map );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "no constants found" );
+  }
+
+}
+
+void BuilderApi::GetConstants( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  const Dali::Property::Map& map  = builder.GetConstants();
+
+  v8::Local object = v8::Object::New( isolate );
+
+  V8Utils::CreatePropertyMap( isolate, map, object );
+
+  args.GetReturnValue().Set( object );
+
+}
+void BuilderApi::CreateAnimation( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  // options =
+  // {
+  //    animation: ..
+  //    constants:
+  //    actor:
+  // }
+  //
+
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  if( !args[0]->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "invalid property map, expecting { animation: x, constants: y, actor: z}" );
+    return;
+  }
+  v8::Local object = args[0]->ToObject();
+
+  std::string animationName;
+  Dali::Property::Map map;
+
+  //  get the animation name and constant map
+
+  GetMapAndString( isolate,
+                   "animation",
+                   animationName,
+                   "constants",
+                   map,
+                   object );
+
+  // actor is optional
+  Actor actor;
+  v8::Local actorValue = object->Get( v8::String::NewFromUtf8( isolate, "actor" ) );
+  if( actorValue->IsObject() )
+  {
+    HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, actorValue->ToObject() );
+    if( handleWrapper )
+    {
+      actor = Actor::DownCast( handleWrapper->mHandle );
+    }
+  }
+  Animation anim;
+  if( actor )
+  {
+    //  Animation CreateAnimation( const std::string& animationName, const Dali::Property::Map& map, Dali::Actor sourceActor );
+    anim = builder.CreateAnimation( animationName, map, actor );
+  }
+  else
+  {
+    anim = builder.CreateAnimation( animationName, map);
+  }
+  v8::Local localObject = AnimationWrapper::WrapAnimation( isolate, anim );
+  args.GetReturnValue().Set( localObject );
+}
+
+void BuilderApi::Create( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  if( !args[0]->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "invalid param");
+    return;
+  }
+  v8::Local object = args[0]->ToObject();
+
+  // options =
+  // {
+  //    template: "my-temppalte",
+  //    constants: {  IMAGE_DIR: "/usr/apps" ,  SHADER_DIR: "/usr/apps/.."}
+  // }
+  //
+  std::string templateName;
+  Dali::Property::Map map;
+
+  GetMapAndString( isolate,
+                   "template",
+                   templateName,
+                   "constants",
+                   map,
+                   object );
+
+  BaseHandle handle = builder.Create( templateName, map );
+  std::string typeName = handle.GetTypeName();
+  ActorWrapper::ActorType actorType = ActorWrapper::GetActorType( typeName );
+
+  if( actorType != ActorWrapper::UNKNOWN_ACTOR )
+  {
+    v8::Local actorObject =  ActorWrapper::WrapActor(isolate, Actor::DownCast(handle),actorType);
+    args.GetReturnValue().Set( actorObject );
+    return;
+  }
+
+  if( typeName == "Animation")
+  {
+    v8::Local animation = AnimationWrapper::WrapAnimation(isolate, Animation::DownCast(handle) );
+    args.GetReturnValue().Set( animation );
+  }
+
+  if( typeName == "Image")
+  {
+    v8::Local image = ImageWrapper::WrapImage(isolate, Image::DownCast(handle) );
+    args.GetReturnValue().Set( image );
+  }
+  if( typeName == "Font ")
+  {
+    v8::Local font = FontWrapper::WrapFont(isolate, Font::DownCast(handle) );
+    args.GetReturnValue().Set( font );
+  }
+  if( typeName == "Shader")
+  {
+    v8::Local shader = ShaderEffectWrapper::WrapShaderEffect(isolate, ShaderEffect::DownCast( handle ));
+    args.GetReturnValue().Set( shader );
+  }
+
+}
+void BuilderApi::ApplyStyle( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  // bool ApplyStyle( const std::string& styleName, Handle& handle );
+
+  bool found(false);
+  std::string styleName = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing style name" );
+    return;
+  }
+
+  Dali::Handle handle = V8Utils::GetHandleParameter( PARAMETER_1, found, isolate, args  );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing handle parameter" );
+    return;
+  }
+
+  builder.ApplyStyle( styleName, handle );
+
+}
+
+void BuilderApi::ApplyFromJson( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  bool found;
+
+  Dali::Handle handle = V8Utils::GetHandleParameter( PARAMETER_0, found, isolate, args  );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing handle parameter" );
+    return;
+  }
+  std::string jsonString = V8Utils::GetStringParameter( PARAMETER_1, found, isolate, args);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing JSON string" );
+    return;
+  }
+  builder.ApplyFromJson( handle, jsonString );
+}
+
+void BuilderApi::AddActors( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  //{
+  //  actor:actor
+  //  section: name
+  //}
+
+  Actor actor;
+
+  if( !args[0]->IsObject() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "invalid param");
+    return;
+  }
+  v8::Local object = args[0]->ToObject();
+
+  v8::Local actorValue = object->Get( v8::String::NewFromUtf8( isolate, "actor" ) );
+  if( actorValue->IsObject() )
+  {
+    HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, actorValue->ToObject() );
+    if( handleWrapper )
+    {
+      actor = Actor::DownCast( handleWrapper->mHandle );
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "actor field not found in param");
+    return;
+  }
+
+  v8::Local stringNameValue = object->Get( v8::String::NewFromUtf8( isolate, "section" ) );
+  if( !stringNameValue->IsString() )
+  {
+    std::string message = "missing field: section";
+    DALI_SCRIPT_EXCEPTION( isolate,  message);
+    return;
+  }
+  std::string sectionName = V8Utils::v8StringToStdString( stringNameValue );
+  if( !sectionName.empty() )
+  {
+    builder.AddActors( sectionName, actor );
+  }
+  else
+  {
+    builder.AddActors(  actor );
+  }
+
+}
+
+void BuilderApi::CreateRenderTask( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+  bool found(false);
+  std::string str = V8Utils::GetStringParameter( 0, found, isolate, args );
+
+  if( found )
+  {
+    builder.CreateRenderTask( str );
+  }
+  else
+  {
+     DALI_SCRIPT_EXCEPTION( isolate, "render task name");
+  }
+}
+
+void BuilderApi::GetShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+  bool found(false);
+  std::string str = V8Utils::GetStringParameter( 0, found, isolate, args );
+  if( found )
+  {
+    ShaderEffect handle = builder.GetShaderEffect( str );
+    v8::Local shader = ShaderEffectWrapper::WrapShaderEffect(isolate, handle);
+    args.GetReturnValue().Set( shader );
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "missing shader name");
+  }
+}
+
+void BuilderApi::GetFrameBufferImage( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+   v8::HandleScope handleScope( isolate );
+   Dali::Toolkit::Builder builder = GetBuilder( isolate, args );
+
+   bool found(false);
+   std::string str = V8Utils::GetStringParameter( 0, found, isolate, args );
+   if( found )
+   {
+     // wrap the image
+     // @TODO Test this, may need to implement a Framebuffer image wrapper.?
+     v8::Local localObject = ImageWrapper::WrapImage( isolate, builder.GetFrameBufferImage(str)  );
+     args.GetReturnValue().Set( localObject );
+   }
+   else
+   {
+     DALI_SCRIPT_EXCEPTION( isolate,  "frame buffer name");
+   }
+
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/toolkit/builder/builder-api.h b/plugins/dali-script-v8/src/toolkit/builder/builder-api.h
new file mode 100644
index 0000000..00ee9a7
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/builder/builder-api.h
@@ -0,0 +1,63 @@
+#ifndef __DALI_V8PLUGIN_BUILDER_API_H__
+#define __DALI_V8PLUGIN_BUILDER_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace BuilderApi
+{
+  /**
+   * Constructor
+   */
+  Dali::Toolkit::Builder New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * Builder API see animation.h for a description
+   */
+  void SetDuration( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void LoadFromString( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void LoadFromFile( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void AddConstants( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetConstants( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void CreateAnimation( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  void Create( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ApplyStyle( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ApplyFromJson(const v8::FunctionCallbackInfo< v8::Value >& args);
+  void AddActors( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void CreateRenderTask( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetShaderEffect( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetFrameBufferImage( const v8::FunctionCallbackInfo< v8::Value >& args );
+}; // namespace BuilderApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_BUILDER_API_H__
diff --git a/plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.cpp b/plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.cpp
new file mode 100644
index 0000000..04617e3
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "builder-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+namespace V8Plugin
+{
+namespace
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction BuilderFunctionTable[]=
+{
+    /**************************************
+    * Builder API (in order of builder.h)
+    **************************************/
+
+    { "LoadFromString"          , BuilderApi::LoadFromString           },
+    { "LoadFromFile"            , BuilderApi::LoadFromFile             },
+    { "AddConstants"            , BuilderApi::AddConstants             },
+    { "GetConstants"            , BuilderApi::GetConstants             },
+    { "CreateAnimation"         , BuilderApi::CreateAnimation          },
+    { "Create"                  , BuilderApi::Create                   },
+    { "ApplyStyle"              , BuilderApi::ApplyStyle               },
+    { "ApplyFromJson"           , BuilderApi::ApplyFromJson            },
+    { "AddActors"               , BuilderApi::AddActors                },
+    { "CreateRenderTask"        , BuilderApi::CreateRenderTask         },
+    { "GetShaderEffect"         , BuilderApi::GetShaderEffect          },
+    { "GetFrameBufferImage"     , BuilderApi::GetFrameBufferImage      }
+};
+
+const unsigned int BuilderFunctionTableCount = sizeof(BuilderFunctionTable)/sizeof(BuilderFunctionTable[0]);
+} //un-named space
+
+
+BuilderWrapper::BuilderWrapper( const Dali::Toolkit::Builder& builder, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::BUILDER , gc )
+{
+    mBuilder = builder;
+}
+
+BuilderWrapper::~BuilderWrapper()
+{
+
+}
+
+v8::Handle BuilderWrapper::WrapBuilder(v8::Isolate* isolate, const Dali::Toolkit::Builder& builder )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetBuilderTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the Builder wrapper
+  BuilderWrapper* pointer =  new BuilderWrapper( builder, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local BuilderWrapper::GetBuilderTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, BuilderFunctionTable, BuilderFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+
+}
+
+void BuilderWrapper::NewBuilder( const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate);
+
+  if( !args.IsConstructCall() )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Builder constructor called without 'new'" );
+    return;
+  }
+
+  Dali::Toolkit::Builder builder = BuilderApi::New( args );
+  v8::Local localObject = WrapBuilder( isolate, builder );
+  args.GetReturnValue().Set( localObject );
+}
+
+
+Dali::Toolkit::Builder BuilderWrapper::GetBuilder()
+{
+  return mBuilder;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.h b/plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.h
new file mode 100644
index 0000000..33445d6
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/builder/builder-wrapper.h
@@ -0,0 +1,74 @@
+#ifndef __DALI_V8PLUGIN_BUILDER_WRAPPER_H__
+#define __DALI_V8PLUGIN_BUILDER_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * Builder  wrapper.
+ * Provides access to Builder specific functionality
+ */
+class BuilderWrapper : public BaseWrappedObject
+{
+
+public:
+
+  BuilderWrapper( const Dali::Toolkit::Builder& builder,
+                GarbageCollectorInterface& gc );
+
+  virtual ~BuilderWrapper();
+
+  /**
+   * @brief Creates a new Builder wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted
+   */
+  static void NewBuilder( const v8::FunctionCallbackInfo< v8::Value >& args);
+
+  /**
+   * Wraps a builder
+   */
+  static v8::Handle WrapBuilder(v8::Isolate* isolate, const Dali::Toolkit::Builder& );
+
+
+  Dali::Toolkit::Builder GetBuilder();
+
+
+private:
+
+  static v8::Local GetBuilderTemplate( v8::Isolate* isolate );
+  Dali::Toolkit::Builder mBuilder;
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_BUILDER_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.cpp b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.cpp
new file mode 100644
index 0000000..d39276c
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.cpp
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "keyboard-focus-manager-api.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace // un named namespace
+{
+
+
+Toolkit::Control::KeyboardFocusNavigationDirection  GetDirection( std::string name,  v8::Isolate* isolate )
+{
+  if( name == "left")
+  {
+    return Dali::Toolkit::Control::Left;
+  }
+  if( name == "right")
+  {
+    return  Dali::Toolkit::Control::Right;
+  }
+  if( name == "up")
+  {
+    return  Dali::Toolkit::Control::Up;
+  }
+  if( name == "down")
+  {
+    return  Dali::Toolkit::Control::Down;
+  }
+
+  DALI_SCRIPT_EXCEPTION( isolate,  "direction not found ( wanted left,right,up,down)" );
+
+
+  return Dali::Toolkit::Control::Up;
+
+}
+}; //un-named namespace
+
+/**
+ * Move the keyboard focus to the given actor.
+ * Only one actor can be focused at the same time.  The actor must
+ * be in the stage already and be keyboard focusable.
+ *
+ * @method setCurrentFocusActor
+ * @for KeyboardFocusManager
+ * @param {Object} Actor
+ */
+void KeyboardFocusManagerApi::SetCurrentFocusActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found( false );
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( ! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "no actor found" );
+    return;
+  }
+
+  Toolkit::KeyboardFocusManager::Get().SetCurrentFocusActor( actor );
+}
+
+/**
+ * Get the current focused actor.
+ *
+ * @method getCurrentFocusActor
+ * @for KeyboardFocusManager
+ * @return {Object} Actor
+ */
+void KeyboardFocusManagerApi::GetCurrentFocusActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, Toolkit::KeyboardFocusManager::Get().GetCurrentFocusActor() );
+  args.GetReturnValue().Set( wrappedActor );
+}
+
+/**
+ * Move the focus to the next focusable actor in the focus
+ * chain in the given direction (according to the focus traversal
+ * order).
+ *
+ * @method moveFocus
+ * @for KeyboardFocusManager
+ * @param {String} direction The direction of focus movement ( left, right, up, down)
+ */
+void KeyboardFocusManagerApi::MoveFocus( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found(false);
+  std::string direction = V8Utils::GetStringParameter( PARAMETER_0, found,isolate, args);
+
+  if( ! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "no direction found" );
+    return;
+  }
+
+  Toolkit::Control::KeyboardFocusNavigationDirection dir = GetDirection( direction, isolate );
+
+  Toolkit::KeyboardFocusManager::Get().MoveFocus( dir );
+}
+/**
+ * Clear the focus from the current focused actor if any, so
+ * that no actor is focused in the focus chain.
+ * It will emit focus changed signal without current focused actor
+ * @method clearFocus
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::ClearFocus( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  Toolkit::KeyboardFocusManager::Get().ClearFocus();
+}
+
+/**
+ * Set whether an actor is a focus group that can limit the
+ * scope of focus movement to its child actors in the focus chain.
+ *
+ * @method setAsFocusGroup
+ * @param {Boolean} enabled Whether the focus movement should be looped
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::SetAsFocusGroup( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  //  void SetAsFocusGroup(Actor actor, bool isFocusGroup);
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found( false );
+
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "missing actor param" );
+    return;
+  }
+
+  bool isFocusGroup = V8Utils::GetBooleanParameter( PARAMETER_1, found,isolate, args);
+  if( ! found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "boolean param missing" );
+    return;
+  }
+
+  Toolkit::KeyboardFocusManager::Get().SetAsFocusGroup( actor,isFocusGroup );
+
+}
+/**
+ * Check whether the actor is set as a focus group or not.
+ * @method isFocusGroup
+ * @param {Object} Actor  The actor to be checked.
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::IsFocusGroup( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found( false );
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing actor parameter");
+    return;
+  }
+  args.GetReturnValue().Set( v8::Boolean::New( isolate,   Toolkit::KeyboardFocusManager::Get().IsFocusGroup(actor) ) );
+}
+
+/**
+ * Returns the closest ancestor of the given actor that is a focus group.
+ * @method getFocusGroup
+ * @param {Object} Actor  The actor to be checked.
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::GetFocusGroup( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found( false );
+
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing actor parameter");
+    return;
+  }
+  Actor retActor  = Toolkit::KeyboardFocusManager::Get().GetFocusGroup( actor );
+  v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, retActor );
+  args.GetReturnValue().Set( wrappedActor );
+
+}
+
+/**
+ * Get whether the focus movement should be looped within the same focus group.
+ * @method setFocusGroupLoop
+ * @param {Object} Actor  he actor to be set as a focus group.
+ * @param {Boolean} isFocusGroup  Whether to set the actor as a focus group or not.
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::SetFocusGroupLoop( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  bool found(false);
+  bool enable = V8Utils::GetBooleanParameter( PARAMETER_0, found,isolate, args);
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate,  "boolean param missing" );
+    return;
+  }
+  Toolkit::KeyboardFocusManager::Get().SetFocusGroupLoop( enable );
+}
+
+/**
+ * Get whether the focus movement should be looped within the same focus group.
+ * @method getFocusGroupLoop
+ * @return  {Boolean} Whether the focus movement should be looped
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::GetFocusGroupLoop( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  args.GetReturnValue().Set( v8::Boolean::New( isolate,   Toolkit::KeyboardFocusManager::Get().GetFocusGroupLoop()) );
+}
+
+/**
+ * Set the focus indicator actor.
+ *
+ * This will replace the default focus indicator actor in
+ * KeyboardFocusManager and will be added to the focused actor as a
+ * highlight.
+ * @method setFocusIndicatorActor
+ * @param {Object} Actor The indicator actor to be added
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::SetFocusIndicatorActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+  bool found(false);
+
+  Actor actor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
+
+  if( !found )
+  {
+    DALI_SCRIPT_EXCEPTION( isolate, "Missing actor parameter");
+    return;
+  }
+
+  // the actor may be an empty handle
+  Toolkit::KeyboardFocusManager::Get().SetFocusIndicatorActor( actor );
+}
+
+
+/**
+ *  Get the focus indicator actor.
+ *
+ * @method getFocusIndicatorActor
+ * @param {Object} Actor The indicator actor to be added
+ * @for KeyboardFocusManager
+ */
+void KeyboardFocusManagerApi::GetFocusIndicatorActor( const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handleScope( isolate );
+
+  v8::Handle < v8::Object > wrappedActor = ActorWrapper::WrapActor( isolate, Toolkit::KeyboardFocusManager::Get().GetFocusIndicatorActor() );
+  args.GetReturnValue().Set( wrappedActor );
+
+}
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.h b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.h
new file mode 100644
index 0000000..c136dc8
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-api.h
@@ -0,0 +1,62 @@
+#ifndef __DALI_V8PLUGIN_KEYBOARD_FOCUS_MANAGER_API_H__
+#define __DALI_V8PLUGIN_KEYBOARD_FOCUS_MANAGER_API_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace KeyboardFocusManagerApi
+{
+  /**
+   * Constructor
+   */
+  Dali::Toolkit::KeyboardFocusManager New( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  /**
+   * KeyboardFocusManager API see keyboard-focus-manager.h for a description
+   */
+  void SetCurrentFocusActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetCurrentFocusActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void MoveFocus( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void ClearFocus( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  void SetAsFocusGroup( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void IsFocusGroup( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetFocusGroup( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  void SetFocusGroupLoop( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetFocusGroupLoop( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+  void SetFocusIndicatorActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+  void GetFocusIndicatorActor( const v8::FunctionCallbackInfo< v8::Value >& args );
+
+}; // namespace KeyboardFocusManagerApi
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // header __DALI_V8PLUGIN_KEYBOARD_FOCUS_MANAGER_API_H__
diff --git a/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.cpp b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.cpp
new file mode 100644
index 0000000..0ab6ea9
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.cpp
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "keyboard-focus-manager-wrapper.h"
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+
+namespace Dali
+{
+namespace V8Plugin
+{
+namespace
+{
+
+/**
+ * Contains a list of all functions that can be called
+ */
+const ApiFunction KeyboardFocusManagerFunctionTable[]=
+{
+    /**************************************
+    * KeyboardFocusManager API (in order of keyboard-focus-manager.h)
+    **************************************/
+
+    { "SetCurrentFocusActor"    , KeyboardFocusManagerApi::SetCurrentFocusActor   },
+    { "GetCurrentFocusActor"    , KeyboardFocusManagerApi::GetCurrentFocusActor   },
+    { "MoveFocus"               , KeyboardFocusManagerApi::MoveFocus              },
+    { "ClearFocus"              , KeyboardFocusManagerApi::ClearFocus             },
+    { "SetAsFocusGroup"         , KeyboardFocusManagerApi::SetAsFocusGroup        },
+    { "IsFocusGroup"            , KeyboardFocusManagerApi::IsFocusGroup           },
+    { "GetFocusGroup"           , KeyboardFocusManagerApi::GetFocusGroup          },
+    { "SetFocusGroupLoop"       , KeyboardFocusManagerApi::SetFocusGroupLoop      },
+    { "GetFocusGroupLoop"       , KeyboardFocusManagerApi::GetFocusGroupLoop      },
+    { "SetFocusIndicatorActor"  , KeyboardFocusManagerApi::SetFocusIndicatorActor },
+    { "GetFocusIndicatorActor"  , KeyboardFocusManagerApi::GetFocusIndicatorActor },
+};
+
+const unsigned int KeyboardFocusManagerFunctionTableCount = sizeof(KeyboardFocusManagerFunctionTable)/sizeof(KeyboardFocusManagerFunctionTable[0]);
+} //un-named space
+
+
+KeyboardFocusManagerWrapper::KeyboardFocusManagerWrapper( const Dali::Toolkit::KeyboardFocusManager& keyboardFocusManager, GarbageCollectorInterface& gc )
+: BaseWrappedObject( BaseWrappedObject::KEYBOARD_FOCUS_MANAGER , gc )
+{
+    mKeyboardFocusManager = keyboardFocusManager;
+}
+
+KeyboardFocusManagerWrapper::~KeyboardFocusManagerWrapper()
+{
+
+}
+
+v8::Handle KeyboardFocusManagerWrapper::WrapKeyboardFocusManager(v8::Isolate* isolate, const Dali::Toolkit::KeyboardFocusManager& keyboardFocusManager )
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  objectTemplate = GetKeyboardFocusManagerTemplate( isolate);
+
+  // create an instance of the template
+  v8::Local localObject = objectTemplate->NewInstance();
+
+  // create the KeyboardFocusManager wrapper
+  KeyboardFocusManagerWrapper* pointer =  new KeyboardFocusManagerWrapper( keyboardFocusManager, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
+
+  // assign the JavaScript object to the wrapper.
+  pointer->SetJavascriptObject( isolate, localObject );
+
+  return handleScope.Escape( localObject );
+}
+
+v8::Local KeyboardFocusManagerWrapper::GetKeyboardFocusManagerTemplate( v8::Isolate* isolate)
+{
+  v8::EscapableHandleScope handleScope( isolate );
+  v8::Local objectTemplate;
+
+  v8::Local objTemplate = v8::ObjectTemplate::New();
+
+  objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
+
+  // add intercepts for Signals, we can't use HandleWrapper::AddIntercepts because KeyboardFocusManager doesn't inherit
+  // from Handle ( just baseHandle)
+  ObjectTemplateHelper::AddSignalConnectAndDisconnect( isolate, objTemplate );
+
+  // add our function properties
+  ObjectTemplateHelper::InstallFunctions( isolate, objTemplate, KeyboardFocusManagerFunctionTable, KeyboardFocusManagerFunctionTableCount );
+
+  return handleScope.Escape( objTemplate );
+
+}
+
+
+std::string KeyboardFocusManagerWrapper::GetDirectionName(  Toolkit::Control::KeyboardFocusNavigationDirection dir )
+{
+  switch( dir )
+  {
+    case Dali::Toolkit::Control::Left:
+    {
+      return "left";
+      break;
+    }
+    case Dali::Toolkit::Control::Right:
+    {
+      return "right";
+      break;
+    }
+    case Dali::Toolkit::Control::Up:
+    {
+      return "up";
+      break;
+    }
+    case Dali::Toolkit::Control::Down:
+    {
+      return "down";
+      break;
+    }
+  }
+  return "unknown direction";
+}
+
+
+Dali::Toolkit::KeyboardFocusManager KeyboardFocusManagerWrapper::GetKeyboardFocusManager()
+{
+  return mKeyboardFocusManager;
+}
+
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.h b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.h
new file mode 100644
index 0000000..3889021
--- /dev/null
+++ b/plugins/dali-script-v8/src/toolkit/focus-manager/keyboard-focus-manager-wrapper.h
@@ -0,0 +1,83 @@
+#ifndef __DALI_V8PLUGIN_KEYBOARD_FOCUS_MANAGER_WRAPPER_H__
+#define __DALI_V8PLUGIN_KEYBOARD_FOCUS_MANAGER_WRAPPER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+/**
+ * KeyboardFocusManager  wrapper.
+ * Provides access to KeyboardFocusManager specific functionality
+ */
+class KeyboardFocusManagerWrapper : public BaseWrappedObject
+{
+
+public:
+
+  KeyboardFocusManagerWrapper( const Dali::Toolkit::KeyboardFocusManager& keyboardFocusManager,
+                GarbageCollectorInterface& gc );
+
+  virtual ~KeyboardFocusManagerWrapper();
+
+/*
+  *
+   * @brief Creates a new KeyboardFocusManager wrapped inside a Javascript Object.
+   * @param[in] args v8 function call arguments interpreted
+
+  static void NewKeyboardFocusManager( const v8::FunctionCallbackInfo< v8::Value >& args);
+*/
+
+  /**
+   * Wraps a keyboardFocusManager
+   */
+  static v8::Handle WrapKeyboardFocusManager(v8::Isolate* isolate, const Dali::Toolkit::KeyboardFocusManager& );
+
+
+  Dali::Toolkit::KeyboardFocusManager GetKeyboardFocusManager();
+
+
+  virtual SignalManager* GetSignalManager() { return &mSignalManager;}
+
+  static std::string GetDirectionName(  Toolkit::Control::KeyboardFocusNavigationDirection dir );
+
+private:
+
+
+  static v8::Local GetKeyboardFocusManagerTemplate( v8::Isolate* isolate );
+  Dali::Toolkit::KeyboardFocusManager mKeyboardFocusManager;
+  SignalManager mSignalManager;
+};
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+#endif // __DALI_V8PLUGIN_KEYBOARD_FOCUS_MANAGER_WRAPPER_H__
diff --git a/plugins/dali-script-v8/src/utils/v8-utils.cpp b/plugins/dali-script-v8/src/utils/v8-utils.cpp
new file mode 100644
index 0000000..1d73b9c
--- /dev/null
+++ b/plugins/dali-script-v8/src/utils/v8-utils.cpp
@@ -0,0 +1,1017 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// HEADER
+#include "v8-utils.h"
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+/**
+ * Similar to DALI_LOG_ERROR except the PRETTY_FUNCTION
+ * is removed because it makes no sense for scripting errors.
+ */
+#define DALI_LOG_SCRIPT_ERROR(format, args...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugError, format, ## args)
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+namespace V8Utils
+{
+
+void Log(const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::HandleScope handleScope( args.GetIsolate());
+
+  bool first = true;
+  for (int i = 0; i < args.Length(); i++)
+  {
+    if (first)
+    {
+      first = false;
+    }
+    else
+    {
+      std::cout << " ";
+    }
+    v8::String::Utf8Value utf8_value( args[i] );
+    std::cout << *utf8_value;
+  }
+}
+
+void LogError(const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::HandleScope handleScope( args.GetIsolate());
+  std::string output;
+  bool first = true;
+  for (int i = 0; i < args.Length(); i++)
+  {
+    if (first)
+    {
+      first = false;
+    }
+    else
+    {
+      output +=" ";
+    }
+    v8::String::Utf8Value utf8_value( args[i] );
+    output += *utf8_value;
+  }
+  DALI_LOG_ERROR_NOFN( "JavaScript: %s",output.c_str() );
+}
+
+void GetFileContents(const std::string &fileName, std::string& contents)
+{
+   std::ifstream t(fileName.c_str());
+   contents = std::string((std::istreambuf_iterator(t)), std::istreambuf_iterator());
+};
+
+void GetFileDirectory( const std::string& fileName, std::string& directory )
+{
+  directory = "";
+
+  // get the position of the last slash
+  size_t pos = fileName.find_last_of("\\/");
+
+  // if it doesn't exist, return nothing
+  if( (std::string::npos == pos ) )
+  {
+    return;
+  }
+  else
+  {
+    // check an edge case where the string ends in a forward slash "mydir/"
+    if( (pos+1) < fileName.length() )
+    {
+      directory = fileName.substr(0, pos+1);
+      return;
+    }
+  }
+}
+
+void GetFileName( const std::string& fullPathName, std::string& fileName )
+{
+  // look for last slash
+  size_t pos = fullPathName.find_last_of("\\/");
+
+  if( std::string::npos == pos )
+  {
+    fileName = fullPathName;
+  }
+  else
+  {
+    fileName = fullPathName.substr(pos,fileName.length());
+  }
+}
+
+void GetModuleName( const std::string& fileName, std::string& moduleName )
+{
+  std::string fileNameNoPath;
+   GetFileName( fileName , fileNameNoPath );
+  size_t pos = fileNameNoPath.find_last_of(".");
+  if( std::string::npos == pos )
+  {
+    moduleName = fileNameNoPath;
+  }
+  else
+  {
+    moduleName = fileName.substr(0, pos );
+  }
+}
+
+void ReportException(  v8::Isolate* isolate, v8::TryCatch* tryCatch)
+{
+  v8::HandleScope handleScope( isolate );
+
+  v8::String::Utf8Value exception(tryCatch->Exception());
+  v8::Handle message   = tryCatch->Message();
+
+  if (message.IsEmpty())
+  {
+    // V8 didn't provide any extra information about this error; just
+    // print the exception.
+    DALI_LOG_SCRIPT_ERROR("%s\n", *exception);
+  }
+  else
+  {
+
+    // Print (filename):(line number): (message).
+    v8::String::Utf8Value filename(message->GetScriptResourceName());
+
+    DALI_LOG_SCRIPT_ERROR("\n\n====== Error found in JavaScript: ========= \n");
+
+
+    int linenum = message->GetLineNumber();
+    DALI_LOG_SCRIPT_ERROR("File: %s\n", *filename, linenum, *exception);
+
+     DALI_LOG_SCRIPT_ERROR("Error: :%s\n", *exception );
+     DALI_LOG_SCRIPT_ERROR("Line: :%i\n",  linenum );
+
+    // Print line of source code.
+    v8::String::Utf8Value sourceline(message->GetSourceLine());
+
+    DALI_LOG_SCRIPT_ERROR("Source: %s\n", *sourceline);
+
+    // Print wavy underline (GetUnderline is deprecated).
+
+    std::stringstream msg;
+
+    int start = message->GetStartColumn();
+    for (int i = 0; i < start; i++)
+    {
+      msg << " ";
+    }
+    int end = message->GetEndColumn();
+    for (int i = start; i < end; i++)
+    {
+      msg << "↑";
+    }
+
+    DALI_LOG_SCRIPT_ERROR("        %s\n", msg.str().c_str());
+
+    v8::String::Utf8Value stack_trace(tryCatch->StackTrace());
+    if (stack_trace.length() > 0)
+    {
+      DALI_LOG_SCRIPT_ERROR("%s\n", *stack_trace);
+    }
+    DALI_LOG_SCRIPT_ERROR("\n=========================================== \n");
+
+  }
+}
+
+std::string GetJavaScriptFunctionName( const char* functionName  )
+{
+  // @todo if we are 100% decided on lower case, go through
+  // every api and manually change the function names to lower case first character
+  std::string name( functionName );
+  name[0]=tolower( functionName[0] );
+  return name;
+}
+
+void Version(const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::HandleScope handleScope( args.GetIsolate());
+
+  v8::Handle  ver = v8::String::NewFromUtf8(args.GetIsolate(), v8::V8::GetVersion());
+
+  args.GetReturnValue().Set(ver);
+}
+
+
+std::string v8StringToStdString( const v8::Handle& value )
+{
+  v8::String::Utf8Value utf8(value);
+  return std::string(*utf8);
+}
+
+
+std::string PropertyNameToJavaScriptName(const std::string& hyphenatedName)
+{
+  std::string ret;
+
+  ret.reserve(hyphenatedName.size());
+
+  bool capitlizeNext = false ;
+  for(unsigned int i = 0; i < hyphenatedName.size(); ++i)
+  {
+    char c = hyphenatedName[i];
+    if(c == '-')
+    {
+      capitlizeNext = true;
+    }
+    else
+    {
+      if(capitlizeNext)
+      {
+        ret.push_back(std::toupper(c));
+        capitlizeNext = false;
+      }
+      else
+      {
+        ret.push_back(c);
+      }
+    }
+  }
+
+  return ret;
+}
+
+
+
+std::string JavaScriptNameToPropertyName(const std::string& camelCase)
+{
+  std::string ret;
+
+  int countUpper = 0;
+  for(unsigned int i = 0; i < camelCase.size(); ++i)
+  {
+    if(std::isupper(camelCase[i]))
+    {
+      countUpper++;
+    }
+  }
+
+  if(countUpper)
+  {
+    ret.reserve(camelCase.size() + countUpper);
+
+    for(unsigned int i = 0; i < camelCase.size(); ++i)
+    {
+      char c = camelCase[i];
+      if(std::isupper(c))
+      {
+        ret.push_back('-');
+      }
+
+      ret.push_back(std::tolower(c));
+    }
+  }
+  else
+  {
+    return camelCase ;
+  }
+
+  return ret;
+}
+
+void ScriptError( const char* function, v8::Isolate* isolate, std::string errorString )
+{
+  v8::EscapableHandleScope scope( isolate);
+  std::string errorMsg = std::string(function) + std::string("(), ") + errorString;
+
+  // log out to DALI_LOG_ERROR first, so we know something has gone wrong
+  DALI_LOG_ERROR("%s \n", errorMsg.c_str() );
+
+  // throw a V8 exception, DALi will keep running but we will get a print out
+  // of where the error occured in the JavaScript source
+  isolate->ThrowException( v8::String::NewFromUtf8( isolate, errorMsg.c_str()) );
+}
+
+bool IsBooleanPrimitiveOrObject( const v8::Local& value )
+{
+  return ( value->IsBoolean() || value->IsBooleanObject());
+}
+
+bool GetBooleanValue( v8::Isolate* isolate, const v8::Local& value )
+{
+  v8::EscapableHandleScope scope( isolate); // may not be required.
+
+  if( value->IsBoolean() )
+  {
+    return value->ToBoolean()->Value();
+  }
+  else if (value->IsBooleanObject() )
+  {
+    const v8::Local object = v8::Local::Cast(value);
+    return object->ValueOf();
+  }
+  DALI_SCRIPT_EXCEPTION(isolate, "no bool found");
+  return false;
+}
+
+bool IsNumberPrimitiveOrObject( const v8::Local& value )
+{
+  return ( value->IsNumber() || value->IsNumberObject());
+}
+
+float GetNumberValue( v8::Isolate* isolate, const v8::Local& value )
+{
+  v8::EscapableHandleScope scope( isolate); // may not be required.
+
+  if( value->IsNumber() )
+  {
+    return value->ToNumber()->Value();
+  }
+  else if (value->IsNumberObject() )
+  {
+    const v8::Local object = v8::Local::Cast(value);
+    return object->ValueOf();
+  }
+
+  DALI_SCRIPT_EXCEPTION(isolate, "no number found?");
+  return 0.f;
+}
+
+bool IsStringPrimitiveOrObject( const v8::Local& value )
+{
+  return ( value->IsString() || value->IsStringObject());
+}
+
+std::string GetStringValue( v8::Isolate* isolate, const v8::Local& value )
+{
+  v8::EscapableHandleScope scope( isolate); // may not be required.
+
+  if( value->IsString() )
+  {
+    return V8Utils::v8StringToStdString(value);
+  }
+  else if (value->IsStringObject() )
+  {
+    const v8::Local object = v8::Local::Cast(value);
+    return V8Utils::v8StringToStdString( object->ValueOf() );
+  }
+
+  DALI_SCRIPT_EXCEPTION(isolate, "no string found?");
+  return "";
+}
+
+
+Property::Value GetPropertyValueFromObject( bool& found, v8::Isolate* isolate, const   v8::Local& value  )
+{
+  v8::HandleScope handleScope( isolate);
+
+  Property::Value  daliPropertyValue;// creates a property with Property::INVALID
+
+  found = false;
+
+  if( value->IsObject() )
+  {
+    v8::Local object = v8::Handle::Cast( value );
+
+    if( BaseWrappedObject::IsWrappedTypeAPropertyValue( object ) )
+    {
+      found = true;
+      PropertyValueWrapper* propertyWrapper = PropertyValueWrapper::Unwrap( isolate, object );
+      return propertyWrapper->GetValue();
+    }
+    else if( value->IsArray() )
+    {
+      found = true;
+      return PropertyValueWrapper::VectorOrMatrixFromV8Array( isolate, object);//todo check for V8 array / map?
+    }
+  }
+  else if( value->IsBoolean() )
+  {
+    found = true;
+    v8::Local v = value->ToBoolean();
+    return Dali::Property::Value(v->Value());
+  }
+  else if( value->IsNumber() )
+  {
+    found = true;
+    v8::Local v = value->ToNumber();
+    return Dali::Property::Value(static_cast(v->Value()));
+  }
+  else if( value->IsInt32() )
+  {
+    found = true;
+    v8::Local v = value->ToInt32();
+    return Dali::Property::Value(static_cast(v->Value()));
+  }
+  else if ( value->IsUint32() )
+  {
+    found = true;
+    v8::Local v = value->ToUint32();
+    return Dali::Property::Value(static_cast(v->Value()));
+  }
+  return daliPropertyValue;
+
+}
+
+Property::Map GetPropertyMapFromObject( v8::Isolate* isolate, const v8::Local& object)
+{
+  v8::Local properties = object->GetPropertyNames();
+  Property::Map propertyMap;    // empty map
+
+  for(  unsigned int i = 0; i <  properties->Length(); ++i)
+  {
+    // Get the key
+    v8::Local key = properties->Get( i );
+    std::string keyString = v8StringToStdString( key );
+
+    // Get the value
+    v8::Local value = object->Get( key );
+    std::string valueString = V8Utils::v8StringToStdString( value );
+
+    propertyMap[ keyString ] = valueString.c_str();
+
+  }
+  return propertyMap;
+}
+
+Actor GetActorFromObject( v8::Isolate* isolate, bool& found, v8::Local& object)
+{
+  v8::HandleScope handleScope( isolate);
+  found = false;
+
+  if( BaseWrappedObject::IsWrappedType ( isolate, object, BaseWrappedObject::ACTOR ))
+  {
+    HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, object );
+    return Actor::DownCast( handleWrapper->mHandle );
+  }
+  return Actor();
+}
+
+
+int GetIntegerParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args, int defaultValue  )
+{
+  found = false;
+  unsigned int length = args.Length();
+  if( index >= length )
+  {
+    return defaultValue;
+  }
+  if( args[ index ]->IsInt32() )
+  {
+    found = true;
+    return args[ index ]->Int32Value();
+  }
+  {
+    return defaultValue;
+  }
+}
+
+float GetFloatParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args, float defaultValue  )
+{
+  found = false;
+  unsigned int length = args.Length();
+  if( index >= length )
+  {
+    return defaultValue;
+  }
+  if( args[ index ]->IsNumber() )
+  {
+    found = true;
+    return args[ index ]->NumberValue();
+  }
+  {
+    return defaultValue;
+  }
+}
+
+std::string GetStringParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  found = false;
+  unsigned int length = args.Length();
+
+  if( index >= length )
+  {
+    return std::string();
+  }
+  if( args[ index ]->IsString() )
+  {
+    found = true;
+    return v8StringToStdString( args[ index ]);
+  }
+  else
+  {
+    return std::string();
+  }
+}
+
+bool GetBooleanParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+
+  found = false;
+  unsigned int length = args.Length();
+  if( index >= length )
+  {
+    return false;
+  }
+  if( args[ index ]->IsBoolean() )
+  {
+    found = true;
+    v8::Local v = args[ index ]->ToBoolean();
+    return v->Value();
+  }
+  else
+  {
+    return false;
+  }
+}
+
+Handle GetHandleParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+
+  found = false;
+  unsigned int length = args.Length();
+  if( index >= length )
+  {
+    return Handle();
+  }
+
+  if( args[ index ]->IsObject() )
+  {
+    v8::Local object = args[ index ]->ToObject();
+    v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+    void* ptr = field->Value();
+    if( ptr )
+    {
+        found = true;
+        HandleWrapper* wrapper = static_cast< HandleWrapper *>(ptr);
+        return wrapper->GetHandle();
+    }
+  }
+  return Handle();
+}
+
+Vector2 GetVector2Parameter( unsigned int index,  bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+  unsigned int length =  args.Length();
+  Vector2 ret;
+  found = false;
+
+  if( index < length )
+  {
+    if( args[ index ]->IsObject() )
+    {
+      Dali::Property::Value value;
+      value = PropertyValueWrapper::ExtractPropertyValue( isolate, args[index], Dali::Property::VECTOR2 );
+      if( value.GetType() == Dali::Property::VECTOR2)
+      {
+        found = true;
+        value.Get(ret);
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, "Missing Vector2 parameter");
+      }
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "Missing Vector2 parameter");
+  }
+
+  return ret;
+}
+
+Vector2 GetVector2ParameterFrom2Float( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  Vector2 ret(0.0f,0.0f);
+  bool bFound(false);
+  unsigned int argCount( args.Length() );
+
+  if( index+2 >= argCount )
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "Missing parameter");
+  }
+
+  found = true;
+  ret.x = V8Utils::GetFloatParameter( index, bFound, isolate, args, 0.0f );
+  found = found && bFound;
+  ret.y = V8Utils::GetFloatParameter( index+1, bFound, isolate, args, 0.0f );
+  found = found && bFound;
+
+  return ret;
+}
+
+Vector3 GetVector3Parameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::HandleScope handleScope( isolate);
+  unsigned int argCount( args.Length() );
+  Vector3 ret;
+  found = false;
+  if( index < argCount )
+  {
+    if( args[ index ]->IsObject() )
+    {
+      Dali::Property::Value value;
+      value = PropertyValueWrapper::ExtractPropertyValue( isolate, args[index], Dali::Property::VECTOR3 );
+      if( value.GetType() == Dali::Property::VECTOR3)
+      {
+        found = true;
+        value.Get(ret);
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, "Missing Vector3 parameter");
+      }
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "Missing Vector3 parameter");
+
+  }
+
+  return ret;
+}
+
+Vector4 GetVector4Parameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args)
+{
+  v8::HandleScope handleScope( isolate);
+  unsigned int argCount( args.Length() );
+  Vector4 ret;
+  found = false;
+
+  if( index < argCount )
+  {
+    if( args[ index ]->IsObject() )
+    {
+      Dali::Property::Value value;
+      value = PropertyValueWrapper::ExtractPropertyValue( isolate, args[index], Dali::Property::VECTOR4 );
+      if( value.GetType() == Dali::Property::VECTOR4)
+      {
+        found = true;
+        value.Get(ret);
+      }
+      else
+      {
+        DALI_SCRIPT_EXCEPTION(isolate, "Missing Vector4 parameter");
+      }
+    }
+  }
+  else
+  {
+    DALI_SCRIPT_EXCEPTION(isolate, "Missing Vector4 parameter");
+  }
+
+  return ret;
+}
+
+
+Rect GetRectIntParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+
+   found = false;
+   int length = args.Length() - index;
+
+   // if it's an array read the 2 numbers into a vector2
+   if( length == 4 )
+   {
+     if( args[ 0 + index ]->IsInt32() &&
+         args[ 1 + index ]->IsInt32() &&
+         args[ 2 + index ]->IsInt32() &&
+         args[ 3 + index ]->IsInt32() )
+     {
+       found = true;
+       Rect rect( args[ 0 + index ]->Int32Value(),
+                       args[ 1 + index ]->Int32Value(),
+                       args[ 2 + index ]->Int32Value(),
+                       args[ 3 + index ]->Int32Value() );
+       return rect;
+     }
+   }
+   // this will extract a Vector4, if it is a Vector4 or a Javascript array object
+   if( args[ index ]->IsObject() )
+   {
+     Dali::Property::Value value;
+     value = PropertyValueWrapper::ExtractPropertyValue( isolate, args[index], Dali::Property::RECTANGLE );
+     if( value.GetType() == Dali::Property::RECTANGLE)
+     {
+       found = true;
+       Rect rect;
+       value.Get(rect);
+       return rect;
+     }
+
+     // @todo support vector4 as well?
+   }
+   return Rect();
+}
+
+Actor GetActorParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  BaseWrappedObject* wrapper = GetWrappedDaliObjectParameter( index, BaseWrappedObject::ACTOR, isolate, args);
+  ActorWrapper* actorWrapper = static_cast< ActorWrapper*>( wrapper );
+  if( actorWrapper )
+  {
+    found = true;
+    return actorWrapper->GetActor();
+  }
+  else
+  {
+    return Actor();
+  }
+}
+
+Layer GetLayerParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  Actor actor = GetActorParameter( index, found, isolate, args );
+  return Layer::DownCast( actor );
+}
+
+Image GetImageParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  BaseWrappedObject* wrappedObject = V8Utils::GetWrappedDaliObjectParameter( index, BaseWrappedObject::IMAGE, isolate, args );
+  if( wrappedObject )
+  {
+    found = true;
+    ImageWrapper* wrapper = static_cast< ImageWrapper *>(wrappedObject);
+    return wrapper->GetImage();
+  }
+  else
+  {
+    return Image();
+  }
+
+}
+RenderTask GetRenderTaskParameter( unsigned int paramIndex, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  found = false;
+  BaseWrappedObject* wrappedObject = V8Utils::GetWrappedDaliObjectParameter( paramIndex, BaseWrappedObject::RENDER_TASK, isolate, args );
+  if( wrappedObject )
+  {
+    found = true;
+    RenderTaskWrapper* wrapper = static_cast< RenderTaskWrapper *>(wrappedObject);
+    return wrapper->GetRenderTask();
+  }
+  else
+  {
+    return RenderTask(); // empty handle
+  }
+}
+
+
+BaseWrappedObject* GetWrappedDaliObjectParameter( unsigned int index,  BaseWrappedObject::Type type,  v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+  unsigned int length = args.Length();
+
+  if( index >= length )
+  {
+    return NULL;
+  }
+
+  if( !args[ index ]->IsObject() )
+  {
+    return NULL;
+  }
+
+  v8::Local object = args[ index ]->ToObject();
+
+  if( BaseWrappedObject::IsWrappedType ( isolate, object, type ))
+  {
+    v8::Local field = v8::Local::Cast( object->GetInternalField(0) );
+    void* ptr = field->Value();
+    BaseWrappedObject* wrapper = static_cast< BaseWrappedObject *>(ptr);
+    return wrapper;
+  }
+  return NULL;
+}
+
+
+Property::Value GetPropertyValueParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+
+  Property::Value  daliPropertyValue;// creates a property with Property::INVALID
+
+  found = false;
+  unsigned int length = args.Length();
+
+  if( index >= length )
+  {
+    return daliPropertyValue;
+  }
+  v8::Local value = args[ index ];
+
+  return GetPropertyValueFromObject( found, isolate, value);
+}
+
+Property::Map GetPropertyMapParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
+{
+  v8::HandleScope handleScope( isolate);
+
+  Property::Map propertyMap;    // empty map
+
+  found = false;
+  unsigned int length = args.Length();
+
+  if( index >= length )
+  {
+    return propertyMap;
+  }
+
+  if( !args[ index ]->IsObject() )
+  {
+    return propertyMap;
+  }
+  found = true;
+
+  // go through each key value pair
+  v8::Local obj = args[ index ]->ToObject();
+
+  return GetPropertyMapFromObject( isolate, obj );
+
+}
+
+void CreatePropertyMap( v8::Isolate* isolate, const Property::Map& map, v8::Local& object )
+{
+  v8::HandleScope handleScope( isolate);
+
+  // we're converting a dali property map in to a JavaScript property map
+  if( map.Count() == 0 )
+  {
+    return;
+  }
+
+  for( unsigned int index = 0; index < map.Count() - 1; ++index )
+  {
+    const std::string& key = map.GetKey( index );
+    Property::Value& value = map.GetValue( index );
+    v8::Local v8Value;
+
+    switch( value.GetType() )
+    {
+      case Dali::Property::FLOAT:
+      {
+        v8Value = v8::Number::New( isolate, value.Get()  );
+        break;
+      }
+      case Dali::Property::BOOLEAN:
+      {
+        v8Value = v8::Boolean::New(  isolate, value.Get());
+        break;
+      }
+      case Dali::Property::INTEGER:
+      {
+        v8Value = v8::Integer::New( isolate, value.Get());
+        break;
+      }
+      case Dali::Property::UNSIGNED_INTEGER:
+      {
+        v8Value = v8::Integer::New( isolate, value.Get());
+        break;
+      }
+      case Dali::Property::STRING:
+      {
+        std::string string = value.Get< std::string >();
+        v8Value = v8::String::NewFromUtf8( isolate,  string.c_str());
+        break;
+      }
+      case Dali::Property::VECTOR2:
+      {
+        // create a vector2
+        Vector2 vec = value.Get();
+        v8::Local array= v8::Array::New( isolate, 2 );
+        array->Set( 0 , v8::Number::New(isolate, vec.x));
+        array->Set( 1 , v8::Number::New(isolate, vec.y));
+        v8Value = array;
+        break;
+      }
+      case Dali::Property::VECTOR3:
+      {
+        // create a vector 3
+        Vector3 vec = value.Get();
+        v8::Local array= v8::Array::New( isolate, 3 );
+        array->Set( 0 , v8::Number::New(isolate, vec.x));
+        array->Set( 1 , v8::Number::New(isolate, vec.y));
+        array->Set( 2 , v8::Number::New(isolate, vec.z));
+        v8Value = array;
+        break;
+      }
+      case Dali::Property::VECTOR4:
+      {
+        // create a vector 4
+        Vector4 vec = value.Get();
+        v8::Local array= v8::Array::New( isolate, 4 );
+        array->Set( 0 , v8::Number::New(isolate, vec.x));
+        array->Set( 1 , v8::Number::New(isolate, vec.y));
+        array->Set( 2 , v8::Number::New(isolate, vec.z));
+        array->Set( 3 , v8::Number::New(isolate, vec.w));
+        v8Value = array;
+        break;
+      }
+
+      default:
+      {
+        DALI_SCRIPT_EXCEPTION( isolate, "Primitive mismatch \n");
+        return;
+      }
+    }
+    object->Set( v8::String::NewFromUtf8( isolate, key.c_str() ), v8Value );
+  }
+}
+
+void ReadFloatArguments( bool& foundAllArguments, float* data, unsigned int dataSize, const v8::FunctionCallbackInfo< v8::Value >& args, float defaultValue )
+{
+  foundAllArguments = true;
+  unsigned int length = args.Length();
+
+  if( length < dataSize )
+  {
+    foundAllArguments = false;
+  }
+
+  for( unsigned int i = 0; i< dataSize ;i++ )
+  {
+    if( i < length )
+    {
+      if( args[ i ]->IsNumber()  )
+      {
+        data[i] = args[i]->NumberValue();
+      }
+      else
+      {
+        data[i] = defaultValue;
+        foundAllArguments = false;   // bad argument
+      }
+    }
+    else
+    {
+      data[i] = defaultValue; // not enough arguments
+    }
+  }
+
+}
+
+void ReadIntegerArguments( bool& foundAllArguments, int* data, int dataSize, const v8::FunctionCallbackInfo< v8::Value >& args, int defaultValue )
+{
+  foundAllArguments = true;
+  int length = args.Length();
+  if( length < dataSize )
+  {
+    foundAllArguments = false;
+  }
+
+  for( int i = 0; i< dataSize ;i++ )
+  {
+    if( i < length )
+    {
+      if( args[ i ]->IsInt32()  )
+      {
+        data[i] = args[i]->Int32Value();
+      }
+      else
+      {
+        data[i] = defaultValue;
+        foundAllArguments = false;   // bad argument
+      }
+    }
+    else
+    {
+      data[i] = defaultValue; // not enough arguments
+    }
+  }
+
+}
+} // namespace V8Utils
+
+} // namespace V8Plugin
+
+} // namespace Dali
diff --git a/plugins/dali-script-v8/src/utils/v8-utils.h b/plugins/dali-script-v8/src/utils/v8-utils.h
new file mode 100644
index 0000000..e8933be
--- /dev/null
+++ b/plugins/dali-script-v8/src/utils/v8-utils.h
@@ -0,0 +1,373 @@
+#ifndef __DALI_V8PLUGIN_V8_UTILS_H__
+#define __DALI_V8PLUGIN_V8_UTILS_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+// INTERNAL INCLUDES
+#include 
+
+namespace Dali
+{
+
+namespace V8Plugin
+{
+
+enum
+{
+  PARAMETER_0 = 0,   ///< first parameter of a function call
+  PARAMETER_1 = 1,   ///< second parameter of a function call
+  PARAMETER_2 = 2,   ///< third parameter of a function call
+  PARAMETER_3 = 3,   ///< forth parameter of a function call
+};
+
+#define DALI_SCRIPT_EXCEPTION( isolate, message ) V8Utils::ScriptError( __FUNCTION__ , isolate, message );
+
+namespace V8Utils
+{
+/**
+ * Print the list of arguments to std out
+ * @param[in] args v8 function args interpreted as (string, string,...)
+ */
+void Log(const v8::FunctionCallbackInfo< v8::Value >& args) ;
+
+/**
+ * Print out using DALI_LOG_ERROR
+ * @param[in] args v8 function args interpreted as (string, string,...)
+ */
+void LogError(const v8::FunctionCallbackInfo< v8::Value >& args) ;
+
+/**
+ * Read a files contents
+ *
+ * @param[in] filename The filename
+ * @param[out] contents string contents of the file
+ */
+void GetFileContents( const std::string &filename, std::string& contents );
+
+/**
+ * Extract the directory path from a full path filename
+ * @param fileName file name
+ * @param directory directory name
+ */
+void GetFileDirectory( const std::string& fileName, std::string& directory );
+
+/**
+ * Extract file name from a full path + file name
+ * @param[in] fullPathName full path + file name
+ * @param[out] fileName file name
+ */
+void GetFileName( const std::string& fullPathName, std::string& fileName);
+
+/**
+ * Return the module name, e.g. if the module is
+ * my_module.js it will get 'my_module'
+ * @param[in] fileName full path module name
+ * @param[out] moduleName module name
+ */
+void GetModuleName( const std::string& fileName, std::string& moduleName );
+
+/**
+ * Report an exception by writing as a warning to the Dali Log
+ *
+ * @param[in] try_catch The v8 TryCatch exception object
+ */
+void ReportException(  v8::Isolate* isolate, v8::TryCatch* try_catch) ;
+
+/**
+ * Depending on what coding standard used this can
+ * convert the first character to lower case,
+ * E.g.  GetId becomes getId
+ */
+std::string GetJavaScriptFunctionName(  const char* functionName );
+
+ /**
+  * Get V8 Version
+  *
+  * @param[in] args v8 function args ignored
+  * @return a version string
+  */
+ void Version(const v8::FunctionCallbackInfo< v8::Value >& args) ;
+
+/**
+ * Convert v8 string as a std::string
+ * @param[in] value v8 function args interpreted as (v8_string)
+ * @return std string
+ */
+ std::string v8StringToStdString( const v8::Handle& value) ;
+
+/**
+ * Convert hyphenated to camelCase (Dali property to wrapper property name)
+ *
+ * @param[in] hyphenatedName a hyphenated std::string to convert
+ * @return a camelCase'd std::string
+ */
+ std::string PropertyNameToJavaScriptName(const std::string& hyphenatedName);
+
+/**
+ * Convert camelCase to hyphenated to (Wrapper property name to Dali property)
+ * E.g. anchorPoint to "anchor-point"
+ * @param[in] camelCase a std::string camelCase
+ * @return a hyphenated std::string conversion
+ */
+ std::string JavaScriptNameToPropertyName(const std::string& camelCase);
+
+/**
+ * Script error, throws an exception
+ */
+void ScriptError( const char* function, v8::Isolate* isolate, std::string errorString );
+
+/**
+ * @return in the value is a boolean primitive or a boolean object
+ */
+bool IsBooleanPrimitiveOrObject( const v8::Local& value );
+
+/**
+ * @return the value of boolean primitive or boolean object value
+ */
+bool GetBooleanValue( v8::Isolate* isolate, const v8::Local& value );
+
+/**
+ * @return true if the value is a number or a number object
+ */
+bool IsNumberPrimitiveOrObject( const v8::Local& value );
+
+/**
+ * @return the number of a number primitive or number object value
+ */
+float GetNumberValue( v8::Isolate* isolate, const v8::Local& value );
+
+/**
+ * @return if the value is a string primitve or a string object
+ */
+bool IsStringPrimitiveOrObject( const v8::Local& value );
+
+/**
+ * @return true if the value is a string or a string object
+ */
+bool IsStringPrimitiveOrObject( const v8::Local& value );
+
+/**
+ * @return the string from a string value or a string object
+ */
+std::string GetStringValue( v8::Isolate* isolate, const v8::Local& value );
+
+/******************************************
+ *  Helper functions for extracting a DALi object from a JavaScript object
+ *******************************************/
+
+/**
+ * Given a JavaScript object, either extract the embedded DALi property value or
+ * convert it to a property value
+ * @param[out] found whether the property was found
+ * @return property value
+ */
+Property::Value GetPropertyValueFromObject( bool& found, v8::Isolate* isolate, const v8::Local& value );
+
+/**
+ * Given a JavaScript object with
+ * @param [in] object JavaScrript object
+ * @return DALi ProperyMap from the  JavaScript object
+ */
+Property::Map GetPropertyMapFromObject( v8::Isolate* isolate, const v8::Local& object);
+
+/**
+ * Extract a DALi wrapped object, from a JavaScript object held in a function argument
+ * @param[in] index argument index the object is held in
+ * @param[in] type type of wrapped object to extract
+ */
+
+Actor GetActorFromObject( v8::Isolate* isolate, bool& found, v8::Local& object);
+
+
+/******************************************
+ *  Helper functions to extract a C++ native type (int,float,string) or a DALi object
+ *  ( handle, vector, actor, layer, property value, property map ) from a
+ *  JavaScript function argument.
+ *  E.g.
+ *  // JavaScript code
+ *     myJavaScriptFunction( 23, 345, myActor );
+ *
+ *  // C++ code
+ * bool found;
+ *
+ * Actor myActor = v8Utils::GetActorParameter( PARAMETER_2, found, JavaScript Args );
+ ******************************************/
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return integer value from the JavaScript function arguments
+ */
+int GetIntegerParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args, int defaultValue  );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return float value from the JavaScript function arguments
+ */
+float GetFloatParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args, float defaultValue  );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return string value from the JavaScript function arguments
+ */
+std::string GetStringParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return boolean value from the JavaScript function arguments
+ */
+bool GetBooleanParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return DALi Handle value from the JavaScript function arguments
+ */
+Handle GetHandleParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args  );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Vector2 from the JavaScript function arguments
+ */
+Vector2 GetVector2Parameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Vector3 from the JavaScript function arguments
+ */
+Vector3 GetVector3Parameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args);
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Vector4 from the JavaScript function arguments
+ */
+Vector4 GetVector4Parameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args);
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Rect from the JavaScript function arguments
+ */
+Rect GetRectIntParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Actor from the JavaScript function arguments
+ */
+Actor GetActorParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Layer from the JavaScript function arguments
+ */
+Layer GetLayerParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return Image from the JavaScript function arguments
+ */
+Image GetImageParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return RenderTask from the JavaScript function arguments
+ */
+RenderTask GetRenderTaskParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * Extract a DALi wrapped object, from a JavaScript object held in a function argument
+ * @param[in] index argument index the object is held in
+ * @param[in] type type of wrapped object to extract
+ */
+BaseWrappedObject* GetWrappedDaliObjectParameter( unsigned int index, BaseWrappedObject::Type type, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return ProperyValue from the  JavaScript function arguments
+ */
+Property::Value GetPropertyValueParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * @param [in] index parameter index, e.g. callMyFunc( index0, index1, index2).
+ * @param[out] found whether the parameter was found
+ * @return ProperyMap from the  JavaScript function arguments
+ */
+Property::Map GetPropertyMapParameter( unsigned int index, bool& found, v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args );
+
+/**
+ * Generate a JavaScript property map, from a DALi property map
+ * @param [in] DALi map property map
+ * @param [in] JavaScript property map
+ */
+void CreatePropertyMap( v8::Isolate* isolate, const Property::Map& map, v8::Local& object );
+
+
+/**
+ * Read multiple float arguments from v8 args object
+ * e.g. myJavaFunc( 3.4, 7.6, 8.5 );
+ *
+ * @param[out] foundAllArguments flag to say all arguments are found
+ * @param[out] data pointer to a pre-allocated array of floats
+ * @param[in] dataSize the nunber of floats in the data parameter
+ * @param[in] defaultValue default value assigned to floats that don't exist in the arguments
+ */
+void ReadFloatArguments( bool& foundAllArguments, float* data, unsigned int dataSize, const v8::FunctionCallbackInfo< v8::Value >& args, float defaultValue );
+
+/**
+ * Read multiple integer arguments from v8 args object
+ * e.g. myJavaFunc( 3, 7, 8 );
+ *
+ * @param[out] foundAllArguments flag to say all arguments are found
+ * @param[out] data pointer to a pre-allocated array of integers
+ * @param[in] dataSize the nunber of integers in the data parameter
+ * @param[in] defaultValue default value assigned to integers that don't exist in the arguments
+ */
+void ReadIntegerArguments( bool& foundAllArguments, int* data, int dataSize, const v8::FunctionCallbackInfo< v8::Value >& args, int defaultValue );
+
+} // namespace V8Utils
+
+} // namespace V8Plugin
+
+} // namespace Dali
+
+
+#endif // __DALI_V8PLUGIN_V8_UTILS_H__
+
-- 
2.7.4


    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