Hello,
this patch adds basic support for the elm_thumb widget to elev8. A demo
script can be found in data/javascript/.
Not yet implemented are the ethumb_client_* calls. I'm not sure if that
should be its own class or if the functions should be included in here.
Regards,
Signed-off-by: Daniel Willmann <d.willm...@samsung.com>
---
trunk/PROTO/elev8/data/javascript/Makefile.am | 1 +
trunk/PROTO/elev8/data/javascript/thumb.js | 65 ++++++
trunk/PROTO/elev8/src/modules/elm/CElmThumb.cc | 257 ++++++++++++++++++++++++
trunk/PROTO/elev8/src/modules/elm/CElmThumb.h | 71 +++++++
trunk/PROTO/elev8/src/modules/elm/Makefile.am | 1 +
trunk/PROTO/elev8/src/modules/elm/main.cc | 2 +
6 files changed, 397 insertions(+)
create mode 100644 trunk/PROTO/elev8/data/javascript/thumb.js
create mode 100644 trunk/PROTO/elev8/src/modules/elm/CElmThumb.cc
create mode 100644 trunk/PROTO/elev8/src/modules/elm/CElmThumb.h
diff --git a/trunk/PROTO/elev8/data/javascript/Makefile.am
b/trunk/PROTO/elev8/data/javascript/Makefile.am
index 27f0436..dbd680a 100644
--- a/trunk/PROTO/elev8/data/javascript/Makefile.am
+++ b/trunk/PROTO/elev8/data/javascript/Makefile.am
@@ -50,6 +50,7 @@ files_SCRIPTS = \
spinner.js \
stock.js \
table.js \
+ thumb.js \
toolbar.js \
twitter.js
diff --git a/trunk/PROTO/elev8/data/javascript/thumb.js
b/trunk/PROTO/elev8/data/javascript/thumb.js
new file mode 100644
index 0000000..eb7c882
--- /dev/null
+++ b/trunk/PROTO/elev8/data/javascript/thumb.js
@@ -0,0 +1,65 @@
+#!/usr/local/bin/elev8
+
+var EXPAND_BOTH = { x : 1.0, y : 1.0 };
+var FILL_BOTH = { x : -1.0, y : -1.0 };
+
+function generateerr_cb(widget)
+{
+ print("Generation error");
+}
+
+function loaderr_cb(widget)
+{
+ print("Load error");
+}
+
+function generate_cb(widget)
+{
+ print("Generation started");
+}
+
+function generated_cb(widget)
+{
+ print("Generation finished");
+}
+
+function clicked_cb(widget)
+{
+ print("Clicked");
+ widget.file = "/usr/local/share/elementary/images/invalid.png";
+}
+
+var desc = elm.Window({
+ label : "Thumb Demo",
+ width : 320,
+ height : 480,
+ align : FILL_BOTH,
+ elements : {
+ the_background : elm.Background ({
+ weight : EXPAND_BOTH,
+ align : FILL_BOTH,
+ resize : true,
+ }),
+ the_box : elm.Box ({
+ weight : EXPAND_BOTH,
+ resize : true,
+ elements : {
+ the_thumb : elm.Thumb ({
+ weight : EXPAND_BOTH,
+ align : FILL_BOTH,
+ editable : false,
+ on_generate_start: generate_cb,
+ on_generate_stop: generated_cb,
+ on_generate_error: generateerr_cb,
+ on_load_error: loaderr_cb,
+ on_click: clicked_cb,
+ }),
+ },
+ }),
+ },
+});
+
+var win = elm.realise(desc);
+var thumb = win.elements.the_box.elements.the_thumb;
+thumb.file = "/usr/local/share/elementary/images/plant_01.jpg";
+thumb.reload();
diff --git a/trunk/PROTO/elev8/src/modules/elm/CElmThumb.cc
b/trunk/PROTO/elev8/src/modules/elm/CElmThumb.cc
new file mode 100644
index 0000000..274c28c
--- /dev/null
+++ b/trunk/PROTO/elev8/src/modules/elm/CElmThumb.cc
@@ -0,0 +1,257 @@
+#include "elm.h"
+#include "CElmThumb.h"
+
+namespace elm {
+
+using namespace v8;
+
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, file);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, path);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, animate);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, editable);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, on_generate_start);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, on_generate_stop);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, on_generate_error);
+GENERATE_PROPERTY_CALLBACKS(CElmThumb, on_load_error);
+GENERATE_METHOD_CALLBACKS(CElmThumb, reload);
+
+GENERATE_TEMPLATE(CElmThumb,
+ METHOD(reload),
+ PROPERTY(file),
+ PROPERTY(path),
+ PROPERTY(animate),
+ PROPERTY(editable),
+ PROPERTY(on_generate_start),
+ PROPERTY(on_generate_stop),
+ PROPERTY(on_generate_error),
+ PROPERTY(on_load_error));
+
+CElmThumb::CElmThumb(Local<Object> _jsObject, CElmObject *parent)
+ : CElmObject(_jsObject, elm_thumb_add(parent->GetEvasObject()))
+{
+}
+
+CElmThumb::~CElmThumb()
+{
+ on_generate_start_set(Undefined());
+ on_generate_stop_set(Undefined());
+ on_generate_error_set(Undefined());
+ on_load_error_set(Undefined());
+}
+
+void CElmThumb::Initialize(Handle<Object> target)
+{
+#ifdef ELM_ETHUMB
+ if (!elm_need_ethumb())
+ {
+ ELM_ERR("Cannot initialize ethumb!");
+ return;
+ }
+#endif
+
+ target->Set(String::NewSymbol("Thumb"), GetTemplate()->GetFunction());
+}
+
+Handle<Value> CElmThumb::reload(const Arguments)
+{
+ elm_thumb_reload(eo);
+ return Undefined();
+}
+
+void CElmThumb::file_set(Handle<Value> val)
+{
+ if (!val->IsString())
+ return;
+
+ String::Utf8Value str(val);
+ elm_thumb_file_set(eo, *str, NULL);
+}
+
+Handle<Value> CElmThumb::file_get(void) const
+{
+ const char *f = NULL;
+
+ elm_thumb_file_get(eo, &f, NULL);
+ if (f)
+ return String::New(f);
+ else
+ return Null();
+}
+
+void CElmThumb::path_set(Handle<Value>)
+{
+ ELM_WRN("path is a read-only attribute!");
+}
+
+Handle<Value> CElmThumb::path_get() const
+{
+ const char *p = NULL;
+
+ elm_thumb_path_get(eo, &p, NULL);
+ if (p)
+ return String::New(p);
+ else
+ return Null();
+}
+
+Handle<Value> CElmThumb::animate_get() const
+{
+ int orient = elm_thumb_animate_get(eo);
+ return Integer::New(orient);
+}
+
+void CElmThumb::animate_set(Handle<Value> val)
+{
+ if (val->IsNumber())
+ elm_thumb_animate_set(eo,
+ (Elm_Thumb_Animation_Setting)val->IntegerValue());
+}
+
+Handle<Value> CElmThumb::editable_get() const
+{
+ return Boolean::New(elm_thumb_editable_get(eo));
+}
+
+void CElmThumb::editable_set(Handle<Value> val)
+{
+ if (val->IsBoolean())
+ elm_thumb_editable_set(eo, val->BooleanValue());
+}
+
+void CElmThumb::OnGenerateStart(void *)
+{
+ Handle<Function> callback(Function::Cast(*cb.generate_start));
+ Handle<Value> args[1] = { jsObject };
+
+ callback->Call(jsObject, 1, args);
+}
+
+void CElmThumb::OnGenerateStartWrapper(void *data, Evas_Object *, void
*event_info)
+{
+ static_cast<CElmThumb*>(data)->OnGenerateStart(event_info);
+}
+
+Handle<Value> CElmThumb::on_generate_start_get() const
+{
+ return cb.generate_start;
+}
+
+void CElmThumb::on_generate_start_set(Handle<Value> val)
+{
+ if (!cb.generate_start.IsEmpty())
+ {
+ evas_object_smart_callback_del(eo, "generate,start",
&OnGenerateStartWrapper);
+ cb.generate_start.Dispose();
+ cb.generate_start.Clear();
+ }
+
+ if (!val->IsFunction())
+ return;
+
+ cb.generate_start = Persistent<Value>::New(val);
+ evas_object_smart_callback_add(eo, "generate,start",
&OnGenerateStartWrapper, this);
+}
+
+void CElmThumb::OnGenerateStop(void *)
+{
+ Handle<Function> callback(Function::Cast(*cb.generate_stop));
+ Handle<Value> args[1] = { jsObject };
+
+ callback->Call(jsObject, 1, args);
+}
+
+void CElmThumb::OnGenerateStopWrapper(void *data, Evas_Object *, void
*event_info)
+{
+ static_cast<CElmThumb*>(data)->OnGenerateStop(event_info);
+}
+
+Handle<Value> CElmThumb::on_generate_stop_get() const
+{
+ return cb.generate_stop;
+}
+
+void CElmThumb::on_generate_stop_set(Handle<Value> val)
+{
+ if (!cb.generate_stop.IsEmpty())
+ {
+ evas_object_smart_callback_del(eo, "generate,stop",
&OnGenerateStopWrapper);
+ cb.generate_stop.Dispose();
+ cb.generate_stop.Clear();
+ }
+
+ if (!val->IsFunction())
+ return;
+
+ cb.generate_stop = Persistent<Value>::New(val);
+ evas_object_smart_callback_add(eo, "generate,stop", &OnGenerateStopWrapper,
this);
+}
+
+void CElmThumb::OnGenerateError(void *)
+{
+ Handle<Function> callback(Function::Cast(*cb.generate_error));
+ Handle<Value> args[1] = { jsObject };
+
+ callback->Call(jsObject, 1, args);
+}
+
+void CElmThumb::OnGenerateErrorWrapper(void *data, Evas_Object *, void
*event_info)
+{
+ static_cast<CElmThumb*>(data)->OnGenerateError(event_info);
+}
+
+Handle<Value> CElmThumb::on_generate_error_get() const
+{
+ return cb.generate_error;
+}
+
+void CElmThumb::on_generate_error_set(Handle<Value> val)
+{
+ if (!cb.generate_error.IsEmpty())
+ {
+ evas_object_smart_callback_del(eo, "generate,error",
&OnGenerateErrorWrapper);
+ cb.generate_error.Dispose();
+ cb.generate_error.Clear();
+ }
+
+ if (!val->IsFunction())
+ return;
+
+ cb.generate_error = Persistent<Value>::New(val);
+ evas_object_smart_callback_add(eo, "generate,error",
&OnGenerateErrorWrapper, this);
+}
+
+void CElmThumb::OnLoadError(void *)
+{
+ Handle<Function> callback(Function::Cast(*cb.load_error));
+ Handle<Value> args[1] = { jsObject };
+
+ callback->Call(jsObject, 1, args);
+}
+
+void CElmThumb::OnLoadErrorWrapper(void *data, Evas_Object *, void *event_info)
+{
+ static_cast<CElmThumb*>(data)->OnLoadError(event_info);
+}
+
+Handle<Value> CElmThumb::on_load_error_get() const
+{
+ return cb.load_error;
+}
+
+void CElmThumb::on_load_error_set(Handle<Value> val)
+{
+ if (!cb.load_error.IsEmpty())
+ {
+ evas_object_smart_callback_del(eo, "load,error", &OnLoadErrorWrapper);
+ cb.load_error.Dispose();
+ cb.load_error.Clear();
+ }
+
+ if (!val->IsFunction())
+ return;
+
+ cb.load_error = Persistent<Value>::New(val);
+ evas_object_smart_callback_add(eo, "load,error", &OnLoadErrorWrapper, this);
+}
+
+}
diff --git a/trunk/PROTO/elev8/src/modules/elm/CElmThumb.h
b/trunk/PROTO/elev8/src/modules/elm/CElmThumb.h
new file mode 100644
index 0000000..75989b6
--- /dev/null
+++ b/trunk/PROTO/elev8/src/modules/elm/CElmThumb.h
@@ -0,0 +1,71 @@
+#ifndef C_ELM_THUMB_H
+#define C_ELM_THUMB_H
+
+#include "elm.h"
+#include "CElmObject.h"
+
+namespace elm {
+
+class CElmThumb : public CElmObject {
+private:
+ static Persistent<FunctionTemplate> tmpl;
+
+protected:
+ CElmThumb(Local<Object> _jsObject, CElmObject *parent);
+ ~CElmThumb();
+
+ static Handle<FunctionTemplate> GetTemplate();
+
+ struct {
+ Persistent<Value> generate_start;
+ Persistent<Value> generate_stop;
+ Persistent<Value> generate_error;
+ Persistent<Value> load_error;
+ } cb;
+
+public:
+ static void Initialize(Handle<Object> target);
+
+ Handle<Value> reload(const Arguments);
+
+ Handle<Value> file_get(void) const;
+ void file_set(Handle<Value> val);
+
+ Handle<Value> path_get() const;
+ void path_set(Handle<Value> val);
+
+ Handle<Value> animate_get() const;
+ void animate_set(Handle<Value> val);
+
+ Handle<Value> editable_get() const;
+ void editable_set(Handle<Value> val);
+
+ void OnGenerateStart(void *event_info);
+ static void OnGenerateStartWrapper(void *data, Evas_Object *, void
*event_info);
+
+ Handle<Value> on_generate_start_get() const;
+ void on_generate_start_set(Handle<Value> val);
+
+ void OnGenerateStop(void *event_info);
+ static void OnGenerateStopWrapper(void *data, Evas_Object *, void
*event_info);
+
+ Handle<Value> on_generate_stop_get() const;
+ void on_generate_stop_set(Handle<Value> val);
+
+ void OnGenerateError(void *event_info);
+ static void OnGenerateErrorWrapper(void *data, Evas_Object *, void
*event_info);
+
+ Handle<Value> on_generate_error_get() const;
+ void on_generate_error_set(Handle<Value> val);
+
+ void OnLoadError(void *event_info);
+ static void OnLoadErrorWrapper(void *data, Evas_Object *, void *event_info);
+
+ Handle<Value> on_load_error_get() const;
+ void on_load_error_set(Handle<Value> val);
+
+ friend Handle<Value> CElmObject::New<CElmThumb>(const Arguments& args);
+};
+
+}
+#endif
diff --git a/trunk/PROTO/elev8/src/modules/elm/Makefile.am
b/trunk/PROTO/elev8/src/modules/elm/Makefile.am
index dee7939..e583f98 100644
--- a/trunk/PROTO/elev8/src/modules/elm/Makefile.am
+++ b/trunk/PROTO/elev8/src/modules/elm/Makefile.am
@@ -53,6 +53,7 @@ libelm_la_SOURCES = \
CElmSlider.cc \
CElmSpinner.cc \
CElmTable.cc \
+ CElmThumb.cc \
CElmToolbar.cc \
CElmWindow.cc
diff --git a/trunk/PROTO/elev8/src/modules/elm/main.cc
b/trunk/PROTO/elev8/src/modules/elm/main.cc
index 7340da5..8cf8b7e 100644
--- a/trunk/PROTO/elev8/src/modules/elm/main.cc
+++ b/trunk/PROTO/elev8/src/modules/elm/main.cc
@@ -43,6 +43,7 @@ using namespace v8;
#include "CElmSlider.h"
#include "CElmSpinner.h"
#include "CElmTable.h"
+#include "CElmThumb.h"
#include "CElmToolbar.h"
#include "CElmWindow.h"
@@ -190,6 +191,7 @@ void RegisterModule(Handle<Object> target)
CElmSlider::Initialize(target);
CElmSpinner::Initialize(target);
CElmTable::Initialize(target);
+ CElmThumb::Initialize(target);
CElmToolbar::Initialize(target);
CElmWindow::Initialize(target);
}
--
1.7.9.5
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and
threat landscape has changed and how IT managers can respond. Discussions
will include endpoint security, mobile security and the latest in malware
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
enlightenment-devel mailing list
enlightenment-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/enlightenment-devel
