').html(response.replace(rscript, "")).find(selector)
+ : response)
+ callback && callback.apply(self, arguments)
+ }
+ $.ajax(options)
+ return this
+ }
+
+ var escape = encodeURIComponent
+
+ function serialize(params, obj, traditional, scope){
+ var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
+ $.each(obj, function(key, value) {
+ type = $.type(value)
+ if (scope) key = traditional ? scope :
+ scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
+ // handle data in serializeArray() format
+ if (!scope && array) params.add(value.name, value.value)
+ // recurse into nested objects
+ else if (type == "array" || (!traditional && type == "object"))
+ serialize(params, value, traditional, key)
+ else params.add(key, value)
+ })
+ }
+
+ $.param = function(obj, traditional){
+ var params = []
+ params.add = function(key, value) {
+ if ($.isFunction(value)) value = value()
+ if (value == null) value = ""
+ this.push(escape(key) + '=' + escape(value))
+ }
+ serialize(params, obj, traditional)
+ return params.join('&').replace(/%20/g, '+')
+ }
+})(Zepto)
+
+;(function($){
+ $.fn.serializeArray = function() {
+ var name, type, result = [],
+ add = function(value) {
+ if (value.forEach) return value.forEach(add)
+ result.push({ name: name, value: value })
+ }
+ if (this[0]) $.each(this[0].elements, function(_, field){
+ type = field.type, name = field.name
+ if (name && field.nodeName.toLowerCase() != 'fieldset' &&
+ !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
+ ((type != 'radio' && type != 'checkbox') || field.checked))
+ add($(field).val())
+ })
+ return result
+ }
+
+ $.fn.serialize = function(){
+ var result = []
+ this.serializeArray().forEach(function(elm){
+ result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
+ })
+ return result.join('&')
+ }
+
+ $.fn.submit = function(callback) {
+ if (0 in arguments) this.bind('submit', callback)
+ else if (this.length) {
+ var event = $.Event('submit')
+ this.eq(0).trigger(event)
+ if (!event.isDefaultPrevented()) this.get(0).submit()
+ }
+ return this
+ }
+
+})(Zepto)
+
+;(function(){
+ // getComputedStyle shouldn't freak out when called
+ // without a valid element as argument
+ try {
+ getComputedStyle(undefined)
+ } catch(e) {
+ var nativeGetComputedStyle = getComputedStyle
+ window.getComputedStyle = function(element, pseudoElement){
+ try {
+ return nativeGetComputedStyle(element, pseudoElement)
+ } catch(e) {
+ return null
+ }
+ }
+ }
+})()
+ return Zepto
+}))
diff --git a/examples/resx/resx.go b/examples/resx/resx.go
new file mode 100644
index 0000000..b290760
--- /dev/null
+++ b/examples/resx/resx.go
@@ -0,0 +1,31 @@
+package resx
+
+import (
+ "embed"
+ "github.com/sciter-sdk/go-sciter"
+ "github.com/sciter-sdk/go-sciter/resx"
+ "github.com/sciter-sdk/go-sciter/window"
+ "log"
+)
+
+
+// embed resource directory
+
+//go:embed html/*
+var f embed.FS
+
+func main() {
+ win, err := window.New(sciter.DefaultWindowCreateFlag, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
+ sciter.SetOption(sciter.SCITER_SET_DEBUG_MODE, 1)
+ //use embed resource
+ resx.HandleDataLoad(win.Sciter, f)
+ //load embed file
+ win.LoadFile("resx://html/index.html")
+ win.SetTitle("title")
+ win.Show()
+ win.Run()
+ log.Println(".....exit.....")
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..1df194a
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,8 @@
+module github.com/sciter-sdk/go-sciter
+
+go 1.16
+
+require (
+ github.com/GeertJohan/go.rice v1.0.2
+ github.com/lxn/win v0.0.0-20210218163916-a377121e959e
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..4aca5f7
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,15 @@
+github.com/GeertJohan/go.incremental v1.0.0/go.mod h1:6fAjUhbVuX1KcMD3c8TEgVUqmo4seqhv0i0kdATSkM0=
+github.com/GeertJohan/go.rice v1.0.2 h1:PtRw+Tg3oa3HYwiDBZyvOJ8LdIyf6lAovJJtr7YOAYk=
+github.com/GeertJohan/go.rice v1.0.2/go.mod h1:af5vUNlDNkCjOZeSGFgIJxDje9qdjsO6hshx0gTmZt4=
+github.com/akavel/rsrc v0.8.0/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
+github.com/daaku/go.zipexe v1.0.0 h1:VSOgZtH418pH9L16hC/JrgSNJbbAL26pj7lmD1+CGdY=
+github.com/daaku/go.zipexe v1.0.0/go.mod h1:z8IiR6TsVLEYKwXAoE/I+8ys/sDkgTzSL0CLnGVd57E=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/lxn/win v0.0.0-20210218163916-a377121e959e h1:H+t6A/QJMbhCSEH5rAuRxh+CtW96g0Or0Fxa9IKr4uc=
+github.com/lxn/win v0.0.0-20210218163916-a377121e959e/go.mod h1:KxxjdtRkfNoYDCUP5ryK7XJJNTnpC8atvtmTheChOtk=
+github.com/nkovacs/streamquote v1.0.0/go.mod h1:BN+NaZ2CmdKqUuTUXUEm9j95B2TRbpOWpxbJYzzgUsc=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13 h1:5jaG59Zhd+8ZXe8C+lgiAGqkOaZBruqrWclLkgAww34=
+golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/include/aux-asset.h b/include/aux-asset.h
new file mode 100644
index 0000000..882c214
--- /dev/null
+++ b/include/aux-asset.h
@@ -0,0 +1,101 @@
+#pragma once
+
+#if defined(_WIN32)
+ #ifndef WIN32_LEAN_AND_MEAN
+ #define WIN32_LEAN_AND_MEAN
+ #endif
+ #define _WINSOCKAPI_
+ #include
+#endif
+
+#include
+#include "sciter-om.h"
+
+namespace aux {
+
+ using namespace sciter::om;
+
+}
+
+#if defined(WINDOWS)
+
+namespace com {
+
+ //asset - yet another smart pointer
+ template
+ class ptr
+ {
+ protected:
+ T* p;
+
+ public:
+ typedef T asset_t;
+
+ ptr():p(0) {}
+ ptr(T* lp):p(0) { if (lp) (p = lp)->AddRef(); }
+ ptr(const ptr& cp):p(0) { if (cp.p) (p = cp.p)->AddRef(); }
+
+ ~ptr()
+ {
+ ULONG c = 0;
+ if (p)
+ c = p->Release();
+ }
+ operator T*() const { return p; }
+ T* operator->() const { assert(p != 0); return p; }
+
+ // used as target T** pointer to pointer - in places receiving newly created objects (initially add-refed)
+ T** target() { release(); return &p; }
+
+ bool operator!() const { return p == 0; }
+ operator bool() const { return p != 0; }
+ bool operator!=(T* pT) const { return p != pT; }
+ bool operator==(T* pT) const { return p == pT; }
+
+ // release the interface and set it to NULL
+ void release() { if (p) { T* pt = p; p = 0; pt->Release(); }}
+
+ // attach to an existing interface (does not AddRef)
+ void attach(T* p2) { release(); p = p2; }
+ // detach the interface (does not Release)
+ T* detach() { T* pt = p; p = 0; return pt; }
+
+ static T* assign(T* &pp, T* lp)
+ {
+ if (lp != 0) lp->AddRef();
+ if (pp) pp->Release();
+ pp = lp;
+ return lp;
+ }
+
+ T* operator=(T* lp) { if(p != lp) return assign(p, lp); return p; }
+ T* operator=(const ptr& lp) { if(p != lp) return assign(p, lp.p); return p; }
+
+ T* acquire() { if( p ) p->AddRef(); return p; }
+
+ HRESULT CoCreateInstance (REFCLSID classUUID, DWORD dwClsContext = CLSCTX_INPROC_SERVER)
+ {
+ HRESULT hr = ::CoCreateInstance (classUUID, 0, dwClsContext, __uuidof (T), (void**) target());
+ assert (hr != CO_E_NOTINITIALIZED); // You haven't called CoInitialize for the current thread!
+ return hr;
+ }
+
+ template
+ HRESULT QueryInterface (REFCLSID classUUID, ptr& dest_object) const
+ {
+ if (p == 0)
+ return E_POINTER;
+ return p->QueryInterface (classUUID, (void**) dest_object.target());
+ }
+
+ template
+ HRESULT QueryInterface (ptr& dest_object) const
+ {
+ return this->QueryInterface (__uuidof (OTHER_COM_CLASS), dest_object);
+ }
+
+ };
+
+}
+
+#endif
diff --git a/include/aux-cvt.h b/include/aux-cvt.h
new file mode 100644
index 0000000..5abe499
--- /dev/null
+++ b/include/aux-cvt.h
@@ -0,0 +1,835 @@
+#ifndef __sciter_aux_h__
+#define __sciter_aux_h__
+
+#if defined(__cplusplus) && !defined( PLAIN_API_ONLY )
+
+/*
+ * Terra Informatica Sciter and HTMLayout Engines
+ * http://terrainformatica.com/sciter, http://terrainformatica.com/htmlayout
+ *
+ * basic primitives.
+ *
+ * The code and information provided "as-is" without
+ * warranty of any kind, either expressed or implied.
+ *
+ * (C) 2003-2015, Andrew Fedoniouk (andrew@terrainformatica.com)
+ */
+
+/**\file
+ * \brief primitives
+ **/
+
+/*
+
+ pod::copy - memcpy wrapper
+ pod::move - memmove wrapper
+ pod::buffer - dynamic buffer, string builder, etc.
+
+ utf8::towcs() - utf8 to WCHAR* converter
+ utf8::fromwcs() - WCHAR* to utf8 converter
+ utf8::ostream - raw ASCII/UNICODE -> UTF8 converter
+ utf8::oxstream - ASCII/UNICODE -> UTF8 converter with XML support
+
+ inline bool streq(const char* s, const char* s1) - NULL safe string comparison function
+ inline bool wcseq(const WCHAR* s, const WCHAR* s1) - NULL safe wide string comparison function
+ inline bool streqi(const char* s, const char* s1) - the same, but case independent
+ inline bool wcseqi(const WCHAR* s, const WCHAR* s1) - the same, but case independent
+
+ w2a - helper object for const WCHAR* to const char* conversion
+ a2w - helper object for const char* to const WCHAR* conversion
+ w2utf - helper object for const WCHAR* to utf8 conversion
+ utf2w - helper object for utf8 to const WCHAR* conversion
+
+ t2w - const TCHAR* to const WCHAR* conversion, #definition
+ w2t - const WCHAR* to const TCHAR* conversion, #definition
+
+ itoa, itow - int to const char* converter
+ atoi, wtoi - const char* to int converter (parser)
+ ftoa, ftow - double to const char* converter
+
+
+ */
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include // std::reverse
+#include "aux-platform.h"
+#include "aux-slice.h"
+
+#include
+#include
+
+// disable that warnings in VC 2005
+#pragma warning(disable:4786) //identifier was truncated...
+#pragma warning(disable:4100) //unreferenced formal parameter
+
+#ifndef BYTE
+ typedef unsigned char BYTE;
+#endif
+
+//#include "aux-slice.h"
+
+// WARNING: macros below must be used only for passing parameters to functions!
+
+/*
+#if !defined(W2A) // WCHAR to multi-BYTE string converter (current locale)
+#define W2A aux::w2a
+#endif
+
+#if !defined(A2W) // multi-BYTE to WCHAR string converter (current locale)
+#define A2W aux::a2w
+#endif
+
+#if !defined(UTF2W) // utf-8 to WCHAR string converter
+#define UTF2W aux::utf2w
+#endif
+
+#if !defined(W2UTF) // WCHAR to utf-8 string converter
+#define W2UTF aux::w2utf
+#endif
+
+#if !defined(W2T)
+#if !defined(UNICODE)
+#define W2T(S) aux::w2a(S)
+#else
+#define W2T(S) (S)
+#endif
+#endif
+
+#if !defined(T2W)
+#if !defined(UNICODE)
+#define T2W(S) aux::a2w(S)
+#else
+#define T2W(S) (S)
+#endif
+#endif
+
+#if !defined(A2T)
+#if !defined(UNICODE)
+#define A2T(S) (S)
+#else
+#define A2T(S) aux::a2w(S)
+#endif
+#endif
+
+#if !defined(T2A)
+#if !defined(UNICODE)
+#define T2A(S) (S)
+#else
+#define T2A(S) aux::w2a(S)
+#endif
+#endif
+
+*/
+
+#ifdef UNICODE
+#define a2t( S ) aux::a2w(S)
+#define t2a( S ) aux::w2a(S)
+#define w2t( S ) (S)
+#define t2w( S ) (S)
+#define t2i( S ) aux::wtoi(S,0)
+#define i2t( S ) aux::itow(S)
+#else
+#define a2t( S ) (S)
+#define t2a( S ) (S)
+#define w2t( S ) aux::w2a(S)
+#define t2w( S ) aux::a2w(S)
+#define t2i( S ) aux::atoi(S,0)
+#define i2t( S ) aux::itoa(S)
+#endif
+
+#define w2u( S ) aux::w2utf(S)
+#define u2w( S ) aux::utf2w(S)
+
+#define i2a( I ) aux::itoa(I)
+#define i2w( I ) aux::itow(I)
+
+inline void* zalloc ( size_t sz)
+{
+ void* p = malloc(sz);
+ if(p) memset(p,0,sz);
+ return p;
+}
+
+//elements in array literal
+#define ITEMS_IN(a) (sizeof(a)/sizeof(a[0]))
+//chars in sting literal
+#define CHARS_IN(s) (sizeof(s) / sizeof(s[0]) - 1)
+
+/**pod namespace - POD primitives. **/
+namespace pod
+{
+ template void copy ( T* dst, const T* src, size_t nelements)
+ {
+ memcpy(dst,src,nelements*sizeof(T));
+ }
+ template void move ( T* dst, const T* src, size_t nelements)
+ {
+ memmove(dst,src,nelements*sizeof(T));
+ }
+
+ /** buffer - in-memory dynamic buffer implementation. **/
+ template
+ class buffer
+ {
+ T* _body;
+ size_t _allocated;
+ size_t _size;
+
+ T* reserve(size_t size)
+ {
+ size_t newsize = _size + size;
+ if( newsize > _allocated )
+ {
+ _allocated = (_allocated * 3) / 2;
+ if(_allocated < newsize) _allocated = newsize;
+ T *newbody = new T[_allocated];
+ copy(newbody,_body,_size);
+ delete[] _body;
+ _body = newbody;
+ }
+ return _body + _size;
+ }
+
+ public:
+
+ buffer():_size(0) { _body = new T[_allocated = 256]; }
+ ~buffer() { delete[] _body; }
+
+ const T * data() const
+ {
+ buffer* self = const_cast(this);
+ if(_size == _allocated) self->reserve(1);
+ self->_body[_size] = 0; return _body;
+ }
+
+ size_t length() const { return _size; }
+
+ void push(T c) { *reserve(1) = c; ++_size; }
+ void push(const T *pc, size_t sz) { copy(reserve(sz),pc,sz); _size += sz; }
+
+ void clear() { _size = 0; }
+
+ };
+
+ typedef buffer byte_buffer;
+ typedef buffer wchar_buffer;
+ typedef buffer char_buffer;
+}
+
+namespace utf8
+{
+ // convert utf8 code unit sequence to WCHAR sequence
+
+ inline bool towcs(const BYTE *utf8, size_t length, pod::wchar_buffer& outbuf)
+ {
+ if(!utf8 || length == 0) return true;
+ const BYTE* pc = (const BYTE*)utf8;
+ const BYTE* last = pc + length;
+ unsigned int b;
+ unsigned int num_errors = 0;
+ while (pc < last)
+ {
+ b = *pc++;
+
+ if( !b ) break; // 0 - is eos in all utf encodings
+
+ if ((b & 0x80) == 0)
+ {
+ // 1-BYTE sequence: 000000000xxxxxxx = 0xxxxxxx
+ ;
+ }
+ else if ((b & 0xe0) == 0xc0)
+ {
+ // 2-BYTE sequence: 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
+ if(pc == last) { outbuf.push('?'); ++num_errors; break; }
+ b = (b & 0x1f) << 6;
+ b |= (*pc++ & 0x3f);
+ }
+ else if ((b & 0xf0) == 0xe0)
+ {
+ // 3-BYTE sequence: zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
+ if(pc >= last - 1) { outbuf.push('?'); ++num_errors; break; }
+
+ b = (b & 0x0f) << 12;
+ b |= (*pc++ & 0x3f) << 6;
+ b |= (*pc++ & 0x3f);
+ if(b == 0xFEFF &&
+ outbuf.length() == 0) // bom at start
+ continue; // skip it
+ }
+ else if ((b & 0xf8) == 0xf0)
+ {
+ // 4-BYTE sequence: 11101110wwwwzzzzyy + 110111yyyyxxxxxx = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
+ if(pc >= last - 2) { outbuf.push('?'); break; }
+
+ b = (b & 0x07) << 18;
+ b |= (*pc++ & 0x3f) << 12;
+ b |= (*pc++ & 0x3f) << 6;
+ b |= (*pc++ & 0x3f);
+ // b shall contain now full 21-bit unicode code point.
+ assert((b & 0x1fffff) == b);
+ if((b & 0x1fffff) != b)
+ {
+ outbuf.push('?');
+ ++num_errors;
+ continue;
+ }
+ outbuf.push( WCHAR(0xd7c0 + (b >> 10)) );
+ outbuf.push( WCHAR(0xdc00 | (b & 0x3ff)) );
+ continue;
+ }
+ else
+ {
+ assert(0); //bad start of UTF-8 multi-BYTE sequence"
+ ++num_errors;
+ b = '?';
+ }
+ outbuf.push( WCHAR(b) );
+ }
+ return num_errors == 0;
+ }
+
+ // gets full unicode code point from UTF16 sequence
+ inline bool get_ucp(aux::wchars &buf, unsigned int& ucp)
+ {
+ if (buf.length == 0)
+ return false;
+ WCHAR c = *buf.start;
+ buf.prune(1);
+ if (c < 0xD800 || c > 0xDBFF) {
+ ucp = c;
+ return true; // not a surrogate pair
+ }
+ if (buf.length == 0) {
+ assert(false); // surrogate pair is not complete
+ ucp = c;
+ return false;
+ }
+ WCHAR nc = *buf.start;
+ buf.prune(1);
+ ucp = (c - 0xD800) * 0x400 + (nc - 0xDC00) + 0x10000;
+ return true;
+ }
+
+ // gets full unicode code point from UTF16 sequence
+ inline bool get_ucp(const WCHAR* &pc, unsigned int& ucp)
+ {
+ if (*pc == 0)
+ return false;
+ WCHAR c = *pc++;
+ if (c < 0xD800 || c > 0xDBFF) {
+ ucp = c;
+ return true; // not a surrogate pair
+ }
+ if (*pc == 0) {
+ assert(false); // surrogate pair is not complete
+ ucp = 0;
+ return false;
+ }
+ WCHAR nc = *pc++;
+ ucp = (c - 0xD800) * 0x400 + (nc - 0xDC00) + 0x10000;
+ return true;
+ }
+
+ inline bool fromwcs(aux::wchars buf, pod::byte_buffer& outbuf)
+ {
+ unsigned int num_errors = 0;
+ unsigned int c; // unicode code point
+
+ while(get_ucp(buf,c))
+ {
+ if (c < (1 << 7))
+ {
+ outbuf.push(BYTE(c));
+ }
+ else if (c < (1 << 11))
+ {
+ outbuf.push(BYTE((c >> 6) | 0xc0));
+ outbuf.push(BYTE((c & 0x3f) | 0x80));
+ }
+ else if (c < (1 << 16))
+ {
+ outbuf.push(BYTE((c >> 12) | 0xe0));
+ outbuf.push(BYTE(((c >> 6) & 0x3f) | 0x80));
+ outbuf.push(BYTE((c & 0x3f) | 0x80));
+ }
+ else if (c < (1 << 21))
+ {
+ outbuf.push(BYTE((c >> 18) | 0xf0));
+ outbuf.push(BYTE(((c >> 12) & 0x3f) | 0x80));
+ outbuf.push(BYTE(((c >> 6) & 0x3f) | 0x80));
+ outbuf.push(BYTE((c & 0x3f) | 0x80));
+ }
+ else
+ ++num_errors;
+ }
+ return num_errors == 0;
+ }
+
+ // UTF8 stream
+
+ // class T must have two methods:
+ // void push(unsigned char c)
+ // void push(const unsigned char *pc, size_t sz)
+
+ // bool X - true - XML markup character conversion (characters '<','>',etc).
+ // false - no conversion at all.
+
+ template
+ class ostream_t : public T
+ {
+ public:
+ ostream_t()
+ {
+ // utf8 BYTE order mark
+ static unsigned char BOM[] = { 0xEF, 0xBB, 0xBF };
+ T::push(BOM, sizeof(BOM));
+ }
+
+ // intended to handle only ascii-7 strings
+ // use this for markup output
+ ostream_t& operator << (const char* str)
+ {
+ T::push((const unsigned char*)str,strlen(str)); return *this;
+ }
+
+ ostream_t& operator << (char c)
+ {
+ T::push((unsigned char)c); return *this;
+ }
+
+ // use UNICODE chars for value output
+ ostream_t& operator << (const WCHAR* wstr)
+ {
+ const WCHAR* p = wstr;
+ unsigned int c;
+ while(get_ucp(p,c))
+ {
+ if(X)
+ switch(c)
+ {
+ case '<': *this << "<"; continue;
+ case '>': *this << ">"; continue;
+ case '&': *this << "&"; continue;
+ case '"': *this << """; continue;
+ case '\'': *this << "'"; continue;
+ }
+ if (c < (1 << 7))
+ {
+ T::push (BYTE(c));
+ }
+ else if (c < (1 << 11)) {
+ T::push (BYTE((c >> 6) | 0xc0));
+ T::push (BYTE((c & 0x3f) | 0x80));
+ }
+ else if (c < (1 << 16)) {
+ T::push (BYTE((c >> 12) | 0xe0));
+ T::push (BYTE(((c >> 6) & 0x3f) | 0x80));
+ T::push (BYTE((c & 0x3f) | 0x80));
+ }
+ else if (c < (1 << 21))
+ {
+ T::push (BYTE((c >> 18) | 0xf0));
+ T::push (BYTE(((c >> 12) & 0x3f) | 0x80));
+ T::push (BYTE(((c >> 6) & 0x3f) | 0x80));
+ T::push (BYTE((c & 0x3f) | 0x80));
+ }
+ }
+ return *this;
+ }
+ ostream_t& operator << (const std::wstring& str)
+ {
+ return *this << (str.c_str());
+ }
+
+ };
+
+ // raw ASCII/UNICODE -> UTF8 converter
+ typedef ostream_t ostream;
+ // ASCII/UNICODE -> UTF8 converter with XML support
+ typedef ostream_t oxstream;
+
+
+} // namespace utf8
+
+namespace aux
+{
+ template struct slice;
+
+ template
+ inline T
+ limit ( T v, T minv, T maxv )
+ {
+ assert(minv < maxv);
+ if (minv >= maxv)
+ return minv;
+ if (v > maxv) return maxv;
+ if (v < minv) return minv;
+ return v;
+ }
+
+ // safe string comparison
+ inline bool streq(const char* s, const char* s1)
+ {
+ if( s && s1 )
+ return strcmp(s,s1) == 0;
+ return false;
+ }
+
+ // safe wide string comparison
+/* inline bool wcseq(const WCHAR* s, const WCHAR* s1)
+ {
+ if( s && s1 )
+ return std::wcscmp(s,s1) == 0;
+ return false;
+ } */
+
+ // safe case independent string comparison
+ inline bool streqi(const char* s, const char* s1)
+ {
+ if( s && s1 )
+
+ return stricmp(s,s1) == 0;
+ return false;
+ }
+
+ // safe case independent wide string comparison
+/* inline bool wcseqi(const WCHAR* s, const WCHAR* s1)
+ {
+ if( s && s1 )
+ return wcsicmp(s,s1) == 0;
+ return false;
+ } */
+
+ // helper convertor objects WCHAR to utf8 and vice versa
+ class utf2w
+ {
+ pod::wchar_buffer buffer;
+ public:
+ explicit utf2w(const BYTE* utf8, size_t length = 0)
+ {
+ if(utf8)
+ {
+ if( length == 0) length = strlen((const char*)utf8);
+ utf8::towcs(utf8, length ,buffer);
+ }
+ }
+ explicit utf2w(const char* utf8, size_t length = 0)
+ {
+ if(utf8)
+ {
+ if( length == 0) length = strlen(utf8);
+ utf8::towcs((const BYTE*)utf8, length ,buffer);
+ }
+ }
+ explicit utf2w(const std::string& utf8)
+ {
+ utf8::towcs((const BYTE*)utf8.c_str(), utf8.length() ,buffer);
+ }
+
+ ~utf2w() {}
+
+ operator const WCHAR*() const { return buffer.data(); }
+ const WCHAR* c_str() const { return buffer.data(); }
+ size_t length() const { return buffer.length(); }
+
+ pod::wchar_buffer& get_buffer() { return buffer; }
+
+ operator aux::wchars() const { return aux::wchars(buffer.data(),buffer.length()); }
+ aux::wchars chars() const { return aux::wchars(buffer.data(),buffer.length()); }
+ //operator std::basic_string() const { return std::basic_string(buffer.data(),buffer.length()); }
+
+ };
+
+ class w2utf
+ {
+ pod::byte_buffer buffer;
+ public:
+ explicit w2utf(const WCHAR* wstr)
+ {
+ if(wstr)
+ {
+ utf8::fromwcs(chars_of(wstr),buffer);
+ }
+ }
+ explicit w2utf(const std::basic_string& str)
+ {
+ utf8::fromwcs(chars_of(str),buffer);
+ }
+ explicit w2utf(wchars str)
+ {
+ utf8::fromwcs(str, buffer);
+ }
+ ~w2utf() {}
+ operator const BYTE*() const { return buffer.data(); }
+ operator const char*() const { return (const char*)buffer.data(); }
+ //operator std::string() const { return std::string(c_str(),length()); }
+
+ const char* c_str() const { return (const char*)buffer.data(); }
+ chars operator()() const { return chars(c_str(),length()); }
+
+ size_t length() const { return buffer.length(); }
+ };
+
+#ifdef WINDOWS
+
+ // helper convertor objects WCHAR to ANSI string and vice versa
+ class w2a
+ {
+ char local[16];
+ char* buffer;
+ size_t n;
+
+ void init(const WCHAR* wstr, size_t nu)
+ {
+ n = WideCharToMultiByte(CP_ACP,0,wstr,int(nu),0,0,0,0);
+ buffer = (n < (16-1))? local:new char[n+1];
+ WideCharToMultiByte(CP_ACP,0,wstr,int(nu),buffer,int(n),0,0);
+ buffer[n] = 0;
+ }
+ public:
+ explicit w2a(const WCHAR* wstr):buffer(0),n(0)
+ {
+ if(wstr)
+ init(wstr,wcslen(wstr));
+ }
+ explicit w2a(const std::basic_string& wstr):buffer(0),n(0)
+ {
+ init(wstr.c_str(),wstr.length());
+ }
+ explicit w2a(slice s):buffer(0), n(0)
+ {
+ init(s.start,s.length);
+ }
+ ~w2a() { if(buffer != local) delete[] buffer; }
+ size_t length() const { return n; }
+ operator const char*() { return buffer; }
+ const char* c_str() const { return buffer; }
+ };
+
+ class a2w
+ {
+ WCHAR local[16];
+ WCHAR* buffer;
+ size_t nu;
+ void init(const char* str, size_t n)
+ {
+#ifdef _WIN32_WCE
+ nu = MultiByteToWideChar(CP_ACP,0,str,n,0,0);
+#else
+ nu = MultiByteToWideChar(CP_THREAD_ACP,0,str,int(n),0,0);
+#endif
+ buffer = ( nu < (16-1) )? local: new WCHAR[nu+1];
+#ifdef _WIN32_WCE
+ MultiByteToWideChar(CP_ACP,0,str,n,buffer,nu);
+#else
+ MultiByteToWideChar(CP_THREAD_ACP,0,str,int(n),buffer,int(nu));
+#endif
+ buffer[nu] = 0;
+ }
+ public:
+ explicit a2w(const char* str):buffer(0), nu(0)
+ {
+ if(str)
+ init(str, strlen(str));
+ }
+ explicit a2w(slice s):buffer(0), nu(0)
+ {
+ init(s.start,s.length);
+ }
+ explicit a2w(const std::string& s):buffer(0), nu(0)
+ {
+ init(s.c_str(),s.length());
+ }
+
+ ~a2w() { if(buffer != local) delete[] buffer; }
+ size_t length() const { return nu; }
+ operator const WCHAR*() const { return buffer; }
+ const WCHAR* c_str() const { return buffer; }
+ operator aux::wchars() const { return aux::wchars(buffer,nu); }
+ aux::wchars chars() const { return aux::wchars(buffer,nu); }
+ //operator std::basic_string() const { return std::basic_string(buffer,nu); }
+
+ };
+
+ class w2oem
+ {
+ char local[64];
+ char* buffer;
+ size_t n;
+
+ void init(const WCHAR* wstr, size_t nu)
+ {
+ n = WideCharToMultiByte(CP_OEMCP,0,wstr,int(nu),0,0,0,0);
+ buffer = (n < (64-1))? local : new char[n+1];
+ WideCharToMultiByte(CP_OEMCP,0,wstr,int(nu),buffer,int(n),0,0);
+ buffer[n] = 0;
+ }
+
+ w2oem(const w2oem &);
+ w2oem& operator=(const w2oem &);
+
+ public:
+ explicit w2oem(const WCHAR* wstr):buffer(0),n(0)
+ {
+ local[0] = 0;
+ if(wstr)
+ init(wstr,wcslen(wstr));
+ }
+ explicit w2oem(const WCHAR* wstr, size_t sz) :buffer(0), n(0)
+ {
+ local[0] = 0;
+ if (wstr)
+ init(wstr, sz);
+ }
+ explicit w2oem(const std::wstring& wstr):buffer(0),n(0)
+ {
+ local[0] = 0;
+ init(wstr.c_str(),wstr.length());
+ }
+ explicit w2oem(slice s);
+
+ ~w2oem() { if(buffer != local) delete[] buffer; }
+ size_t length() const { return n; }
+ operator const char*() { return buffer; }
+ const char* c_str() const { return buffer; }
+ };
+
+#elif defined(UTF8_CHARS)
+ typedef utf2w a2w;
+ typedef w2utf w2a;
+ typedef utf2w oem2w;
+ typedef w2utf w2oem;
+#else
+ #error "unknown char string representation"
+#endif
+
+ /** Integer to string converter.
+ Use it as wostream << itow(234)
+ **/
+
+template
+ class itot
+ {
+ CT buffer[38];
+ public:
+ itot(int n, int radix = 10)
+ {
+ static char num[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+ CT* wstr = buffer;
+ if (radix < 2 || radix > 35) { *wstr = 0; return; } // validate radix
+ int sign = n; if (sign < 0) n = -n;
+ do { *wstr++ = num[n % radix]; } while( n /= radix ); // conversion. number is reversed.
+ if(sign<0) *wstr++ ='-';
+ *wstr = 0;
+ // reverse the string
+ std::reverse(buffer,wstr);
+ }
+ operator const CT*() { return buffer; }
+ };
+
+ typedef itot itoa;
+ typedef itot itow;
+
+
+ /** Float to string converter.
+ Use it as ostream << ftoa(234.1); or
+ Use it as ostream << ftoa(234.1,"pt"); or
+ **/
+ class ftoa
+ {
+ char buffer[64];
+ public:
+ ftoa(double d, const char* units = "", int fractional_digits = 1)
+ {
+ snprintf(buffer, sizeof(buffer), "%.*f%s", fractional_digits, d, units );
+ buffer[63] = 0;
+ }
+ operator const char*() { return buffer; }
+ };
+
+ /** Float to wstring converter.
+ Use it as wostream << ftow(234.1); or
+ Use it as wostream << ftow(234.1,"pt"); or
+ **/
+ /*class ftow
+ {
+ WCHAR buffer[64];
+ public:
+ ftow(double d, const WCHAR* units = "", int fractional_digits = 1)
+ {
+#ifdef WINDOWS
+ _snwprintf_s(buffer, 64, L"%.*f%s", fractional_digits, d, units );
+#else
+ swprintf(buffer, 64, L"%.*f%s", fractional_digits, d, units );
+#endif
+ buffer[63] = 0;
+ }
+ operator const WCHAR*() { return buffer; }
+ };*/
+
+ /** string to integer parser. **/
+ inline int atoi(const char *s, int default_value = 0)
+ {
+ if( !s ) return default_value;
+ char *lastptr;
+ long i = strtol( s, &lastptr, 10 );
+ return (lastptr != s)? (int)i : default_value;
+ }
+
+ /** wstring to integer parser. **/
+ inline int wtoi(const WCHAR *s, int default_value = 0)
+ {
+ w2a at(s);
+ return atoi(at.c_str(),default_value);
+ }
+
+ // class T must have two methods:
+ // void push(WCHAR c)
+ // void push(const WCHAR *pc, size_t sz)
+ template
+ class ostream_t : public T
+ {
+ public:
+ ostream_t() {}
+
+ // intended to handle only ascii-7 strings
+ // use this for markup output
+ ostream_t& operator << (const char* str)
+ {
+ if(!str) return *this;
+ while( *str ) T::push(*str++);
+ return *this;
+ }
+
+ ostream_t& operator << (char c)
+ {
+ T::push(c); return *this;
+ }
+
+ // intended to handle only ascii-7 strings
+ // use this for markup output
+ ostream_t& operator << (const WCHAR* str)
+ {
+ if(!str || !str[0]) return *this;
+ T::push(str,wcslen(str)); return *this;
+ }
+
+ ostream_t& operator << (WCHAR c)
+ {
+ T::push(c); return *this;
+ }
+ };
+
+ // wostream - a.k.a. wstring builder - buffer for dynamic composition of WCHAR strings
+ typedef ostream_t wostream;
+}
+
+#endif
+#endif
diff --git a/include/aux-platform.h b/include/aux-platform.h
new file mode 100644
index 0000000..63490e5
--- /dev/null
+++ b/include/aux-platform.h
@@ -0,0 +1,50 @@
+#ifndef __aux_platform_h__
+#define __aux_platform_h__
+
+/*
+ * Terra Informatica Sciter and HTMLayout Engines
+ * http://terrainformatica.com/sciter, http://terrainformatica.com/htmlayout
+ *
+ * platform primitives.
+ *
+ * The code and information provided "as-is" without
+ * warranty of any kind, either expressed or implied.
+ *
+ * (C) 2003-2015, Andrew Fedoniouk (andrew@terrainformatica.com)
+ */
+
+
+#if defined(WIN64) || defined(_WIN64) || defined(_M_X64)
+ #define WINDOWS
+ #define X64BITS
+#elif defined(WIN32) || defined(_WIN32)
+ #define WINDOWS
+#elif defined(__APPLE__)
+ #define OSX
+ #define UTF8_CHARS // const char* is UTF8 sequence
+ #ifdef __x86_64__
+ #define X64BITS
+ #endif
+ #define POSIX
+#elif defined( __linux__ )
+ #ifndef LINUX
+ #define LINUX
+ #endif
+ #ifdef __x86_64__
+ #define X64BITS
+ #endif
+ #define POSIX
+ #define UTF8_CHARS // const char* is UTF8 sequence
+#else
+ #error "Unknown platform"
+#endif
+
+#if defined(WINDOWS)
+ #define stricmp _stricmp
+ #define wcsicmp _wcsicmp
+#elif defined(POSIX)
+ #define stricmp strcasecmp
+ #define wcsicmp wcscasecmp
+#endif
+
+#endif
diff --git a/include/aux-slice.h b/include/aux-slice.h
new file mode 100644
index 0000000..992e544
--- /dev/null
+++ b/include/aux-slice.h
@@ -0,0 +1,542 @@
+#ifndef __aux_slice_h__
+#define __aux_slice_h__
+
+#if defined(__cplusplus) && !defined( PLAIN_API_ONLY )
+
+/*
+ * Terra Informatica Sciter and HTMLayout Engines
+ * http://terrainformatica.com/sciter, http://terrainformatica.com/htmlayout
+ *
+ * slice - range of elements, start/length. That is what is known in D as array.
+ *
+ * The code and information provided "as-is" without
+ * warranty of any kind, either expressed or implied.
+ *
+ * (C) 2003-2015, Andrew Fedoniouk (andrew@terrainformatica.com)
+ */
+
+/**\file
+ * \brief range of elements
+ **/
+
+#include
+#include "limits.h"
+#include
+#include "sciter-x-primitives.h"
+
+namespace aux
+{
+
+ inline bool is_space( char c ) { return isspace(c & 0xff) != 0; }
+ inline bool is_space( WCHAR c ) { return iswspace(c) != 0; }
+
+ inline bool is_digit( char c ) { return isdigit(c & 0xff) != 0; }
+ inline bool is_digit( WCHAR c ) { return iswdigit(c) != 0; }
+
+ inline bool is_xdigit( char c ) { return isdigit(c & 0xff) != 0; }
+ inline bool is_xdigit( WCHAR c ) { return iswxdigit(c) != 0; }
+
+ inline bool is_alpha( char c ) { return isalpha(c & 0xff) != 0; }
+ inline bool is_alpha( WCHAR c ) { return iswalpha(c) != 0; }
+
+ inline bool is_alnum( char c ) { return isalnum(c & 0xff) != 0; }
+ inline bool is_alnum( WCHAR c ) { return iswalnum(c) != 0; }
+
+ template
+ inline size_t wcslen( const CT* s ) { const CT *p = s; while (*p) p++; return p - s; }
+
+template
+ struct slice
+ {
+ const T* start;
+ size_t length;
+
+ slice(): start(0), length(0) {}
+ slice(const T* start_, size_t length_) { start = start_; length = length_; }
+ slice(const slice& src): start(src.start), length(src.length) {}
+
+ slice& operator = (const slice& src) { start = src.start; length = src.length; return *this; }
+
+ // definitions to support for(auto a : slice) {} loops in C++11
+ const T* begin() const { return start; }
+ const T* end() const { return start + length; }
+
+ bool operator == ( const slice& r ) const
+ {
+ if( length != r.length )
+ return false;
+ if( start == r.start )
+ return true;
+ for( unsigned int i = 0; i < length; ++i )
+ if( start[i] != r.start[i] )
+ return false;
+ return true;
+ }
+
+ bool operator != ( const slice& r ) const { return !operator==(r); }
+
+ T operator[] ( unsigned int idx ) const
+ {
+ assert( idx < length );
+ if(idx < length)
+ return start[idx];
+ return 0;
+ }
+
+ T last() const
+ {
+ if(length)
+ return start[length-1];
+ return 0;
+ }
+
+ // [idx1..length)
+ slice operator() ( unsigned int idx1 ) const
+ {
+ assert( idx1 < length );
+ if ( idx1 < length )
+ return slice( start + idx1, length - idx1 );
+ return slice();
+ }
+ // [idx1..idx2)
+ slice operator() ( unsigned int idx1, unsigned int idx2 ) const
+ {
+ assert( idx1 < length );
+ assert( idx2 <= length );
+ assert( idx1 <= idx2 );
+ if ( idx1 < idx2 )
+ return slice( start + idx1, idx2 - idx1 );
+ return slice();
+ }
+
+ int index_of( T e ) const
+ {
+ for( unsigned int i = 0; i < length; ++i ) if( start[i] == e ) return i;
+ return -1;
+ }
+
+ int last_index_of( T e ) const
+ {
+ for( size_t i = length; i > 0 ;) if( start[--i] == e ) return int(i);
+ return -1;
+ }
+
+ int index_of( const slice& s ) const
+ {
+ if( s.length > length ) return -1;
+ if( s.length == 0 ) return -1;
+ size_t l = length - s.length;
+ for( unsigned int i = 0; i < l ; ++i)
+ if( start[i] == *s.start )
+ {
+ const T* p = s.start;
+ size_t last = i + s.length;
+ for( unsigned int j = i + 1; j < last; ++j )
+ if( *(++p) != start[j])
+ goto next_i;
+ return i;
+ next_i: continue;
+ }
+ return -1;
+ }
+
+ int last_index_of( const slice& s ) const
+ {
+ if( s.length > length ) return -1;
+ if( s.length == 0 ) return -1;
+ const T* ps = s.end() - 1;
+ for( size_t i = length; i > 0 ; )
+ if( start[--i] == *ps )
+ {
+ const T* p = ps;
+ size_t j, first = i - s.length + 1;
+ for( j = i; j > first; )
+ if( *(--p) != start[--j])
+ goto next_i;
+ return int(j);
+ next_i: continue;
+ }
+ return -1;
+ }
+
+ template
+ bool starts_with(const slice &s) const {
+ if (length < s.length)
+ return false;
+ slice t(start, s.length);
+ return t == s;
+ }
+
+ bool ends_with(const slice &s) const {
+ if (length < s.length)
+ return false;
+ slice t(start + length - s.length, s.length);
+ return t == s;
+ }
+
+ void prune(size_t from_start, size_t from_end = 0)
+ {
+ size_t s = from_start >= length? length : from_start;
+ size_t e = length - (from_end >= length? length: from_end);
+ start += s;
+ if( s < e ) length = e-s;
+ else length = 0;
+ }
+
+ bool split(const slice &delimeter, slice &head, slice &tail) const {
+ int d = index_of(delimeter);
+ if (d < 0)
+ return false;
+ const T *s = start;
+ size_t l = length;
+ head = slice(s, d);
+ tail = slice(s + d + delimeter.length, l - d - delimeter.length);
+ return true;
+ }
+
+
+#ifdef CPP11
+ explicit
+#endif
+ operator bool() const { return length > 0; }
+
+ T operator *() const { return length ? start[0] : T(); }
+
+ T operator++() { if (length) { ++start; if (--length) return *start; } return T(); }
+ T operator++(int) { if (length) { --length; ++start; return *(start - 1); } return T(); }
+
+ bool like(const T* pattern) const;
+
+ };
+
+ #define MAKE_SLICE( T, D ) slice(D, sizeof(D) / sizeof(D[0]))
+
+ // gets (static) array of elements and constructs slice of it (start/length pair)
+ template
+ inline slice make_slice(const T(&arr)[size]) { return slice(&arr[0], size); }
+
+ #ifdef _DEBUG
+
+ inline void slice_unittest()
+ {
+ int v1[] = { 0,1,2,3,4,5,6,7,8,9 };
+ int v2[] = { 3,4,5 };
+ int v3[] = { 0,1,2 };
+ int v4[] = { 0,1,2,4 };
+ int v5[] = { 1,1,2,3 };
+
+ slice s1 = MAKE_SLICE( int, v1 );
+ slice s2 = MAKE_SLICE( int, v2 );
+ slice s3 = MAKE_SLICE( int, v3 );
+ slice s4 = MAKE_SLICE( int, v4 );
+ slice s5 = MAKE_SLICE( int, v5 );
+
+ assert( s1 != s2 );
+ assert( s1(3,6) == s2 );
+ assert( s1.index_of(3) == 3 );
+ assert( s1.index_of(s2) == 3 );
+ assert( s1.last_index_of(3) == 3 );
+ assert( s1.last_index_of(s2) == 3 );
+
+ assert( s1.index_of(s3) == 0 );
+ assert( s1.last_index_of(s3) == 0 );
+
+ assert( s1.index_of(s4) == -1 );
+ assert( s1.last_index_of(s4) == -1 );
+
+ assert( s1.index_of(s5) == -1 );
+ assert( s1.last_index_of(s5) == -1 );
+
+ }
+
+ #endif
+
+ template
+ inline slice trim_left(slice str)
+ {
+ for( unsigned i = 0; i < str.length; ++i )
+ if( is_space(str[0]) ) { ++str.start; --str.length; }
+ else break;
+ return str;
+ }
+
+ template
+ inline slice trim_right(slice str)
+ {
+ for( int j = int(str.length) - 1; j >= 0; --j )
+ if( is_space(str[j]) ) --str.length;
+ else break;
+ return str;
+ }
+
+ template
+ inline slice trim(slice str)
+ {
+ return trim_right(trim_left(str));
+ }
+
+ typedef slice chars;
+ typedef slice wchars;
+ typedef slice bytes;
+
+
+ // Note: CS here is a string literal!
+ #define const_chars(CS) aux::slice(CS,CHARS_IN(CS))
+ #define const_wchars(CS) aux::slice(WSTR(CS),CHARS_IN(_WSTR(CS)))
+
+ inline wchars chars_of( const WCHAR *t ) { return t? wchars(t,(unsigned int)wcslen(t)):wchars(); }
+ inline chars chars_of( const char *t ) { return t? chars(t,(unsigned int)strlen(t)):chars(); }
+
+
+
+ template
+ slice chars_of( const std::basic_string &s ) { return slice(s.c_str(), s.length()); }
+
+ template
+ slice elements_of(const T* s, size_t l) { return slice(s, l); }
+
+ template
+ slice elements_of( const std::vector &s ) { return slice(s.data(), s.size()); }
+
+ template
+ slice elements_of(T (& arr)[size]){ return slice(&arr[0],size);}
+
+ template
+ slice elements_of(const T (& arr)[size]){ return slice(&arr[0],size);}
+
+ template
+ std::basic_string make_string( aux::slice s ) { return std::basic_string(s.start, s.length); }
+
+ // simple tokenizer
+ template
+ class tokens
+ {
+ const T* delimeters;
+ const T* p;
+ const T* tail;
+ const T* start;
+ const T* end;
+ const bool is_delimeter(T el) { for(const T* t = delimeters;t && *t; ++t) if(el == *t) return true; return false; }
+ const T* tok() { for(;p < tail; ++p) if(is_delimeter(*p)) return p++; return p; }
+ public:
+
+ tokens(const T *text, size_t text_length, const T* separators): delimeters(separators)
+ {
+ start = p = text;
+ tail = p + text_length;
+ end = tok();
+ }
+
+ tokens(const aux::slice s, const T* separators): delimeters(separators)
+ {
+ start = p = s.start;
+ tail = p + s.length;
+ end = tok();
+ }
+
+ bool next(slice& v)
+ {
+ if(start < tail)
+ {
+ v.start = start;
+ v.length = unsigned(end - start);
+ start = p;
+ end = tok();
+ return true;
+ }
+ return false;
+ }
+ };
+
+ typedef tokens atokens;
+ typedef tokens wtokens;
+
+
+ /****************************************************************************/
+ //
+ // idea was taken from Konstantin Knizhnik's FastDB
+ // see http://www.garret.ru/
+ // extended by [] operations
+ //
+
+ template
+ struct charset
+ {
+ #define SET_SIZE (1 << (sizeof(CT) * CHAR_BIT))
+ #define SIGNIFICANT_BITS_MASK unsigned( SET_SIZE - 1 )
+
+ unsigned char codes[ SET_SIZE / CHAR_BIT ];
+
+ unsigned charcode(CT c) // proper unsigned_cast
+ {
+ return SIGNIFICANT_BITS_MASK & unsigned(c);
+ }
+
+ private:
+ void set ( CT from, CT to, bool v )
+ {
+ for ( unsigned i = charcode(from); i <= charcode(to); ++i )
+ {
+ unsigned int bit = i & 7;
+ unsigned int octet = i >> 3;
+ if( v ) codes[octet] |= 1 << bit; else codes[octet] &= ~(1 << bit);
+ }
+ }
+ void init ( unsigned char v ) { memset(codes,v,(SET_SIZE >> 3)); }
+ public:
+
+ void parse ( const CT* &pp )
+ {
+ //assert( sizeof(codes) == sizeof(CT) * sizeof(bool));
+ const CT *p = (const CT *) pp;
+ unsigned char inv = *p == '^'? 0xff:0;
+ if ( inv ) { ++p; }
+ init ( inv );
+ if ( *p == sep ) set(sep,sep,inv == 0);
+ while ( *p )
+ {
+ if ( p[0] == end ) { p++; break; }
+ if ( p[1] == sep && p[2] != 0 ) { set (p[0], p[2], inv == 0 ); p += 3; }
+ else { CT t = *p++; set(t,t, inv == 0); }
+ }
+ pp = (const CT *) p;
+ }
+
+ bool valid ( CT c )
+ {
+ unsigned int bit = charcode(c) & 7;
+ unsigned int octet = charcode(c) >> 3;
+ return (codes[octet] & (1 << bit)) != 0;
+ }
+ #undef SET_SIZE
+ #undef SIGNIFICANT_BITS_MASK
+ };
+
+ template
+ inline int match ( slice cr, const CT *pattern )
+ {
+ const CT AnySubstring = '*';
+ const CT AnyOneChar = '?';
+ const CT AnyOneDigit = '#';
+
+ const CT *str = cr.start;
+ const CT *wildcard = 0;
+ const CT *strpos = 0;
+ const CT *matchpos = 0;
+
+ charset cset;
+
+ for (;;)
+ {
+ if ( *pattern == AnySubstring )
+ {
+ wildcard = ++pattern;
+ strpos = str;
+ if ( !matchpos ) matchpos = str;
+ }
+ else if ( *str == '\0' || str >= cr.end() )
+ {
+ return ( *pattern == '\0' ) ? int( matchpos - cr.start ) : -1;
+ }
+ else if ( *pattern == '[' )
+ {
+ pattern++;
+ cset.parse ( pattern );
+ if ( !cset.valid ( *str ) )
+ return -1;
+ if ( !matchpos )
+ matchpos = str;
+ str += 1;
+ }
+ else if ( *str == *pattern || *pattern == AnyOneChar )
+ {
+ if ( !matchpos ) matchpos = str;
+ str += 1;
+ pattern += 1;
+ }
+ else if (*pattern == AnyOneDigit)
+ {
+ if (isdigit(*str)) {
+ if (!matchpos) matchpos = str;
+ str++;
+ pattern++;
+ }
+ else if (wildcard) {
+ str = ++strpos;
+ pattern = wildcard;
+ }
+ else
+ return -1;
+ }
+ else if ( wildcard )
+ {
+ str = ++strpos;
+ pattern = wildcard;
+ }
+ else
+ break;
+ }
+ return -1;
+ }
+
+ template
+ inline bool slice::like ( const T *pattern ) const
+ {
+ return match(*this,pattern) >= 0;
+ }
+
+ // chars to unsigned int
+ // chars to int
+
+ template
+ inline unsigned int to_uint(slice& span, unsigned int base = 10)
+ {
+ unsigned int result = 0,value;
+ const T *cp = span.start;
+ const T *pend = span.end();
+
+ while ( cp < pend && is_space(*cp) ) ++cp;
+
+ if (!base)
+ {
+ base = 10;
+ if (*cp == '0') {
+ base = 8;
+ cp++;
+ if ((toupper(*cp) == 'X') && is_xdigit(cp[1])) {
+ cp++;
+ base = 16;
+ }
+ }
+ }
+ else if (base == 16)
+ {
+ if (cp[0] == '0' && toupper(cp[1]) == 'X')
+ cp += 2;
+ }
+ while ( cp < pend && is_xdigit(*cp) &&
+ (value = is_digit(*cp) ? *cp-'0' : toupper(*cp)-'A'+10) < base) {
+ result = result*base + value;
+ cp++;
+ }
+ span.length = (unsigned int)(cp - span.start);
+ return result;
+ }
+
+ template
+ int to_int(slice& span, unsigned int base = 10)
+ {
+
+ while (span.length > 0 && is_space(span[0]) ) { ++span.start; --span.length; }
+ if(span[0] == '-')
+ {
+ ++span.start; --span.length;
+ return - int(to_uint(span,base));
+ }
+ return to_uint(span,base);
+ }
+
+}
+
+#endif
+#endif
diff --git a/include/behaviors/behavior_camera_capture.cpp b/include/behaviors/behavior_camera_capture.cpp
new file mode 100644
index 0000000..929d3f0
--- /dev/null
+++ b/include/behaviors/behavior_camera_capture.cpp
@@ -0,0 +1,127 @@
+
+#include "sciter-x.h"
+
+#if TRUE // change it to FALSE to disable camera functionality
+
+#include
+#include
+#include "camera/camera-capture.h"
+#include "camera/camera-capture.cpp"
+
+namespace sciter
+{
+/*
+
+BEHAVIOR: camera_stream
+ provides video frames from camera
+COMMENTS:
+
+SAMPLE:
+ See: samples/video/video-camera-behavior.htm
+*/
+
+struct camera_stream: public event_handler
+{
+ com::ptr pcapt;
+ sciter::om::hasset rendering_site;
+ // ctor
+ camera_stream() {}
+ virtual ~camera_stream() {}
+
+ virtual bool subscription( HELEMENT he, UINT& event_groups )
+ {
+ event_groups = HANDLE_BEHAVIOR_EVENT; // we only handle VIDEO_BIND_RQ here
+ return true;
+ }
+
+ virtual void attached (HELEMENT he ) { }
+ virtual void detached (HELEMENT he ) { asset_release(); }
+
+ virtual bool on_event (HELEMENT he, HELEMENT target, BEHAVIOR_EVENTS type, UINT_PTR reason )
+ {
+ if(type != VIDEO_BIND_RQ)
+ return false;
+ // we handle only VIDEO_BIND_RQ requests here
+
+ if( !reason )
+ return true; // first phase, consume the event to mark as we will provide frames
+
+ rendering_site = (sciter::video_destination*) reason;
+ return true;
+ }
+
+ /*
+ sciter::value get_devices() {
+ camera::device_list devices;
+ devices.enumerate_devices();
+ sciter::value r;
+ for( unsigned n = 0; n < devices.count(); ++n ) {
+ sciter::string name;
+ if(devices.get_device_name(n,name))
+ r.append( sciter::value(name) );
+ }
+ return r;
+ }
+
+ sciter::value stream_from( const sciter::value& device ) // either int (index) or string (name)
+ {
+ if(pcapt)
+ pcapt->end_capture();
+ pcapt = camera::capture::create_instance(rendering_site,device);
+ return sciter::value(true);
+ }
+
+ // scripting methods
+ BEGIN_FUNCTION_MAP
+ FUNCTION_0("devices",get_devices) // devices() : (array of strings), get list of names of devices
+ FUNCTION_1("streamFrom",stream_from) // streamFrom(indexOrName: int | string), start streaming from the camera
+ END_FUNCTION_MAP
+ */
+
+ std::vector get_devices() {
+ camera::device_list devices;
+ devices.enumerate_devices();
+ std::vector out;
+ for (unsigned n = 0; n < devices.count(); ++n) {
+ sciter::string name;
+ if (devices.get_device_name(n, name))
+ out.push_back(name);
+ }
+ return out;
+ }
+
+ bool stream_from(const sciter::value& device) // either int (index) or string (name)
+ {
+ if (pcapt)
+ pcapt->end_capture();
+ pcapt = camera::capture::create_instance(rendering_site, device);
+ return true;
+ }
+
+ SOM_PASSPORT_BEGIN_EX(camera, camera_stream)
+ SOM_PROPS(
+ SOM_RO_VIRTUAL_PROP(devices, get_devices),
+ )
+ SOM_FUNCS(
+ SOM_FUNC_EX(streamFrom, stream_from),
+ )
+ SOM_PASSPORT_END
+
+};
+
+struct camera_stream_factory: public behavior_factory {
+
+ camera_stream_factory(): behavior_factory("camera") {}
+
+ // the only behavior_factory method:
+ virtual event_handler* create(HELEMENT he) { return new camera_stream(); }
+
+};
+
+// instantiating and attaching it to the global list
+camera_stream_factory camera_stream_factory_instance;
+
+
+}
+
+#endif
\ No newline at end of file
diff --git a/include/behaviors/behavior_drawing-gdi.cpp b/include/behaviors/behavior_drawing-gdi.cpp
new file mode 100644
index 0000000..ccf3ddf
--- /dev/null
+++ b/include/behaviors/behavior_drawing-gdi.cpp
@@ -0,0 +1,163 @@
+#include "stdafx.h"
+#include "sciter-x.h"
+#include "sciter-x-behavior.h"
+#include "sciter-x-graphics.hpp"
+
+namespace sciter
+{
+/*
+BEHAVIOR: gdi-drawing
+ - draws content layer using GDI primitives.
+
+SAMPLE:
+ See: samples/behaviors/gdi-drawing.htm
+*/
+
+// dib (bitmap) combined with DC
+
+class dib32
+ {
+ const unsigned _width;
+ const unsigned _height;
+ void* _bits;
+ mutable HBITMAP _old_bitmap;
+ mutable HDC _dc;
+ HBITMAP _bitmap;
+
+ BITMAPINFO _bitmap_info;
+
+ public:
+
+ dib32(unsigned w, unsigned h) :
+ _width(w),
+ _height(h),
+ _bits(0),
+ _old_bitmap(0),
+ _dc(0) {
+
+ memset(&_bitmap_info,0,sizeof(_bitmap_info));
+ _bitmap_info.bmiHeader.biSize = sizeof(_bitmap_info.bmiHeader);
+ _bitmap_info.bmiHeader.biWidth = _width;
+ _bitmap_info.bmiHeader.biHeight = 0 - int(_height);
+ _bitmap_info.bmiHeader.biPlanes = 1;
+ _bitmap_info.bmiHeader.biBitCount = 32;
+ _bitmap_info.bmiHeader.biCompression = BI_RGB;
+
+ _bitmap = ::CreateDIBSection(
+ NULL, // device context
+ &_bitmap_info,
+ DIB_RGB_COLORS,
+ &_bits,
+ 0, // file mapping object
+ 0); // file offset
+
+ if (0 == _bits) {
+ return;
+ //throw std::bad_alloc();
+ }
+
+ memset(_bits,0, _width * _height * 4);
+
+ }
+
+ ~dib32() {
+ if( _dc )
+ {
+ ::SelectObject(_dc,_old_bitmap);
+ ::DeleteDC(_dc);
+ }
+ if( _bitmap )
+ ::DeleteObject(_bitmap);
+ }
+
+ void set_white()
+ {
+ memset(_bits,0xff, _width * _height * 4);
+ }
+
+ unsigned width() const { return _width; }
+ unsigned height() const { return _height; }
+ void* bits() const { return _bits; }
+ BYTE* bytes() const { return (BYTE*)_bits; }
+ HDC DC() const
+ {
+ if(!_dc) {
+ _dc = ::CreateCompatibleDC(NULL);
+ if (_dc)
+ _old_bitmap = (HBITMAP)::SelectObject(_dc,_bitmap);
+ }
+ return _dc;
+ }
+
+ HBITMAP detach() { auto r = _bitmap; _bitmap = 0; return r; }
+
+ const BITMAPINFO& get_info() const { return _bitmap_info; }
+ };
+
+
+struct gdi_drawing: public event_handler
+{
+ // ctor
+ gdi_drawing() {}
+ virtual ~gdi_drawing() {}
+
+ virtual bool subscription( HELEMENT he, UINT& event_groups )
+ {
+ event_groups = HANDLE_DRAW; // it does drawing
+ return true;
+ }
+
+ virtual void attached (HELEMENT he ) { }
+ virtual void detached (HELEMENT he ) { asset_release(); }
+
+ virtual bool handle_draw (HELEMENT he, DRAW_PARAMS& params )
+ {
+ if( params.cmd != DRAW_CONTENT ) return false; // drawing only content layer
+
+ unsigned w = unsigned(params.area.right - params.area.left);
+ unsigned h = unsigned(params.area.bottom - params.area.top);
+
+ dib32 buffer(w,h);
+
+ do_draw(buffer.DC(), w,h);
+
+ sciter::image img = sciter::image::create(w,h,false,buffer.bytes());
+
+ sciter::graphics gfx(params.gfx);
+
+ gfx.draw_image(&img, POS(params.area.left), POS(params.area.top));
+
+ return true;
+
+ }
+
+ void do_draw( HDC hdc, unsigned width, unsigned height ) {
+ RECT rc = { 0,0,int(width),int(height) };
+ HBRUSH hbr1 = ::CreateSolidBrush(0x000000);
+ HBRUSH hbr2 = ::CreateSolidBrush(0x0000FF);
+ // fill it by black color:
+ ::FillRect(hdc,&rc,hbr1);
+ ::InflateRect(&rc,-40,-40);
+ ::FillRect(hdc,&rc,hbr2);
+ ::DeleteObject(hbr1);
+ ::DeleteObject(hbr2);
+ }
+
+};
+
+struct gdi_drawing_factory: public behavior_factory {
+
+ gdi_drawing_factory(): behavior_factory("gdi-drawing") { }
+
+ // the only behavior_factory method:
+ virtual event_handler* create(HELEMENT he) {
+ return new gdi_drawing();
+ }
+
+};
+
+// instantiating and attaching it to the global list
+gdi_drawing_factory gdi_drawing_factory_instance;
+
+
+}
diff --git a/include/behaviors/behavior_drawing-opengl.cpp b/include/behaviors/behavior_drawing-opengl.cpp
new file mode 100644
index 0000000..f2bbb91
--- /dev/null
+++ b/include/behaviors/behavior_drawing-opengl.cpp
@@ -0,0 +1,156 @@
+#include "stdafx.h"
+#include "sciter-x.h"
+#include "sciter-x-behavior.h"
+#include "sciter-x-graphics.hpp"
+
+#if defined(WINDOWS)
+ #define WIN32_LEAN_AND_MEAN
+ #include
+ #include
+ #include
+ #pragma comment(lib, "OpenGL32.lib")
+ #pragma comment(lib, "Glu32.lib")
+#elif defined(OSX)
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+#elif defined(LINUX)
+ #include
+ #include
+ #include
+#endif
+
+
+namespace sciter
+{
+/*
+SAMPLE:
+ See: samples/behaviors/native-drawing.htm
+*/
+
+struct molehill_opengl: public event_handler
+{
+ HWND hwnd = NULL;
+ HGLRC mainGLRC = NULL;
+ HGLRC thisGLRC = NULL;
+ HDC hdc = NULL;
+
+ float theta = 0;
+ INT32 color1 = 0xFF0000;
+ INT32 color2 = 0x00FF00;
+ INT32 color3 = 0x0000FF;
+
+ // ctor
+ molehill_opengl() {}
+ virtual ~molehill_opengl() {}
+
+ virtual bool subscription( HELEMENT he, UINT& event_groups )
+ {
+ event_groups = HANDLE_ALL; // it does drawing
+ return true;
+ }
+
+ virtual void attached (HELEMENT he )
+ {
+ hwnd = dom::element(he).get_element_hwnd(true);
+ }
+ virtual void detached (HELEMENT he ) {
+ wglDeleteContext(thisGLRC);
+ ReleaseDC(hwnd, hdc);
+ asset_release();
+ }
+
+ void init_drawing() {
+
+ if (!mainGLRC) {
+ mainGLRC = wglGetCurrentContext();
+ hdc = GetDC(hwnd);
+ thisGLRC = wglCreateContext(hdc);
+ wglShareLists(mainGLRC, thisGLRC);
+ }
+
+ }
+
+ void set_color(INT32 clr) {
+ glColor3f(
+ (clr & 0xFF) / 255.0f,
+ ((clr >> 8) & 0xFF) / 255.0f,
+ ((clr >> 16) & 0xFF) / 255.0f);
+ }
+
+ virtual bool handle_draw (HELEMENT he, DRAW_PARAMS& params )
+ {
+ if( params.cmd != DRAW_CONTENT )
+ return false; // drawing only content layer
+
+ HGLRC currentGLRC = wglGetCurrentContext();
+ if (!currentGLRC)
+ return false;
+
+ sciter::graphics gfx(params.gfx);
+
+ gfx.flush(); // we need to flush current command buffers in order our own
+ // commands to appear on top of them.
+ init_drawing();
+
+ // Do our own OpenGL drawing:
+
+ // make it the current rendering context
+ wglMakeCurrent(hdc, thisGLRC);
+
+ //--- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // do not clear what is drawn underneath
+
+ glPushMatrix();
+ glRotatef(theta, 0.0f, 0.0f, 1.0f);
+ glBegin(GL_TRIANGLES);
+ set_color(color1); glVertex2f(0.0f, 1.0f);
+ set_color(color2); glVertex2f(0.87f, -0.5f);
+ set_color(color3); glVertex2f(-0.87f, -0.5f);
+ glEnd();
+ glPopMatrix();
+
+ glFlush();
+
+ // make the rendering context not current
+ wglMakeCurrent(hdc, currentGLRC);
+
+ return true; // done drawing
+
+ }
+
+
+ // script API
+
+ SOM_PASSPORT_BEGIN_EX(molehill,molehill_opengl)
+ //SOM_FUNCS()
+ SOM_PROPS(
+ SOM_PROP(theta),
+ SOM_PROP(color1),
+ SOM_PROP(color2),
+ SOM_PROP(color3)
+ )
+ SOM_PASSPORT_END
+
+
+
+};
+
+struct molehill_opengl_factory: public behavior_factory {
+
+ molehill_opengl_factory(): behavior_factory("molehill-opengl") { }
+
+ // the only behavior_factory method:
+ virtual event_handler* create(HELEMENT he) {
+ return new molehill_opengl();
+ }
+
+};
+
+// instantiating and attaching it to the global list
+molehill_opengl_factory molehill_opengl_factory_instance;
+
+
+}
diff --git a/include/behaviors/behavior_drawing.cpp b/include/behaviors/behavior_drawing.cpp
new file mode 100644
index 0000000..180dc44
--- /dev/null
+++ b/include/behaviors/behavior_drawing.cpp
@@ -0,0 +1,225 @@
+//#include "stdafx.h"
+#include "sciter-x.h"
+#include "sciter-x-behavior.h"
+#include "sciter-x-graphics.hpp"
+#include
+#include
+
+using namespace std;
+
+namespace sciter
+{
+/*
+BEHAVIOR: native-clock
+ - draws content layer using sciter-x-graphics.hpp primitives.
+
+SAMPLE:
+ See: samples/behaviors/native-drawing.htm
+*/
+
+struct native_clock: public event_handler
+{
+ // ctor
+ native_clock() {}
+ virtual ~native_clock() {}
+
+ virtual bool subscription( HELEMENT he, UINT& event_groups )
+ {
+ event_groups = HANDLE_DRAW // it does drawing
+ | HANDLE_TIMER; // and handles timer
+ return true;
+ }
+
+ virtual void attached (HELEMENT he )
+ {
+ dom::element(he).start_timer(1000,this);
+ }
+ virtual void detached (HELEMENT he ) {
+ dom::element(he).stop_timer(this);
+ asset_release();
+ }
+
+
+ virtual bool handle_timer (HELEMENT he,TIMER_PARAMS& params )
+ {
+ dom::element(he).refresh(); // refresh element's area
+ return true; // keep ticking
+ }
+
+ virtual bool handle_draw (HELEMENT he, DRAW_PARAMS& params )
+ {
+ if( params.cmd != DRAW_CONTENT ) return false; // drawing only content layer
+
+ const float PI = 3.141592653f;
+
+ float w = float(params.area.right - params.area.left);
+ float h = float(params.area.bottom - params.area.top);
+
+ float scale = w < h? w / 300.0f: h / 300.0f;
+
+ time_t rawtime;
+ time (&rawtime);
+ struct tm timeinfo = *localtime (&rawtime);
+
+ sciter::graphics gfx(params.gfx);
+ gfx.state_save();
+
+ gfx.translate(params.area.left + w / 2.0f,params.area.top + h / 2.0f);
+ gfx.scale(scale,scale);
+ gfx.rotate(-PI/2);
+ gfx.line_color(0);
+ gfx.line_width(8.f);
+ gfx.line_cap(SCITER_LINE_CAP_ROUND);
+
+ // Hour marks
+ gfx.state_save();
+ gfx.line_color(gcolor(0x32,0x5F,0xA2));
+ for (int i = 0; i < 12; ++i) {
+ gfx.rotate(PI/6);
+ gfx.line(137.f,0,144.f,0);
+ }
+ gfx.state_restore();
+
+ // Minute marks
+ gfx.state_save();
+ gfx.line_width(3.f);
+ gfx.line_color(gcolor(0xA5,0x2A, 0x2A));
+ for (int i = 0; i < 60; ++i) {
+ if ( i % 5 != 0)
+ gfx.line(143,0,146,0);
+ gfx.rotate(PI/30.f);
+ }
+ gfx.state_restore();
+
+ int sec = timeinfo.tm_sec;
+ int min = timeinfo.tm_min;
+ int hr = timeinfo.tm_hour;
+ hr = hr >= 12 ? hr - 12 : hr;
+
+ // draw Hours
+ gfx.state_save();
+ gfx.rotate( hr*(PI/6) + (PI/360)*min + (PI/21600)*sec );
+ gfx.line_width(14);
+ gfx.line_color(gcolor(0x32,0x5F,0xA2));
+ gfx.line(-20,0,70,0);
+ gfx.state_restore();
+
+ // draw Minutes
+ gfx.state_save();
+ gfx.rotate( (PI/30)*min + (PI/1800)*sec );
+ gfx.line_width(10);
+ gfx.line_color(gcolor(0x32,0x5F,0xA2));
+ gfx.line(-28,0,100,0);
+ gfx.state_restore();
+
+ // draw seconds
+ gfx.state_save();
+ gfx.rotate(sec * PI/30);
+ gfx.line_color(gcolor(0xD4,0,0));
+ gfx.fill_color(gcolor(0xD4,0,0));
+ gfx.line_width(6);
+ gfx.line(-30,0,83,0);
+ gfx.ellipse(0,0,10,10);
+
+ gfx.fill_color(0);
+ gfx.ellipse(95,0,10,10);
+ gfx.state_restore();
+
+ gfx.state_restore();
+
+ char buffer[16] = { 0 };
+ sprintf(buffer, "%02d:%02d", timeinfo.tm_hour, timeinfo.tm_min);
+
+ //sciter::text text(aux::chars_of(buffer), he);
+ sciter::text text = sciter::text::create_with_style(aux::a2w(buffer), he, const_wchars("font-size:24pt;color:brown"));
+ gfx.draw_text(text, params.area.left + w / 2.0f, params.area.top + h / 4.0f, 5);
+
+ return false;
+
+ }
+
+
+ // generation of Graphics.Path object on native side to be passed to script for drawing
+
+ sciter::value getPath(float x, float y, float w, float h, float t, bool closed)
+ {
+ float samples[6];
+ float sx[6], sy[6];
+ float dx = w/5.0f;
+
+ samples[0] = (1+sinf(t*1.2345f+cosf(t*0.33457f)*0.44f))*0.5f;
+ samples[1] = (1+sinf(t*0.68363f+cosf(t*1.3f)*1.55f))*0.5f;
+ samples[2] = (1+sinf(t*1.1642f+cosf(t*0.33457f)*1.24f))*0.5f;
+ samples[3] = (1+sinf(t*0.56345f+cosf(t*1.63f)*0.14f))*0.5f;
+ samples[4] = (1+sinf(t*1.6245f+cosf(t*0.254f)*0.3f))*0.5f;
+ samples[5] = (1+sinf(t*0.345f+cosf(t*0.03f)*0.6f))*0.5f;
+
+ for (int i = 0; i < 6; i++) {
+ sx[i] = x+i*dx;
+ sy[i] = y+h*samples[i]*0.8f;
+ }
+
+ // creating path:
+ sciter::path p = sciter::path::create();
+
+ p.move_to(sx[0], sy[0],false);
+ for(int i = 1; i < 6; ++i)
+ p.bezier_curve_to(sx[i-1]+dx*0.5f,sy[i-1], sx[i]-dx*0.5f,sy[i], sx[i],sy[i],false);
+
+ if( closed ) {
+ p.line_to(x+w,y+h,false);
+ p.line_to(x+0,y+h,false);
+ p.close_path();
+ }
+ // .line_to(points[n],points[n+1]);
+ return p.to_value(); // wrap the path into sciter::value;
+ }
+
+ class IMGPainter : public sciter::painter {
+ public:
+ void paint(sciter::graphics& gfx, UINT width, UINT height)
+ {
+ gfx.line_width(3);
+ gfx.line_color(sciter::gcolor(255, 0, 0));
+ gfx.line(0, 0, sciter::POS(width), sciter::POS(height));
+ gfx.line(sciter::POS(width), 0, 0, sciter::POS(height));
+ }
+ };
+
+ sciter::value getImage(int width, int height)
+ {
+ BYTE *b = new BYTE[width * height * 4];
+ memset(b, 127, width * height * 4);
+
+ sciter::image img = sciter::image::create(width, height, false, b);
+
+ IMGPainter painter;
+ img.paint(&painter);
+ return img.to_value();
+ }
+
+ SOM_PASSPORT_BEGIN_EX(nativeClock,native_clock)
+ SOM_FUNCS(
+ SOM_FUNC(getPath),
+ SOM_FUNC(getImage)
+ )
+ SOM_PASSPORT_END
+
+};
+
+struct native_clock_factory: public behavior_factory {
+
+ native_clock_factory(): behavior_factory("native-clock") { }
+
+ // the only behavior_factory method:
+ virtual event_handler* create(HELEMENT he) {
+ return new native_clock();
+ }
+
+};
+
+// instantiating and attaching it to the global list
+native_clock_factory native_clock_factory_instance;
+
+
+}
diff --git a/include/behaviors/behavior_native_textarea.cpp b/include/behaviors/behavior_native_textarea.cpp
new file mode 100644
index 0000000..95afbe4
--- /dev/null
+++ b/include/behaviors/behavior_native_textarea.cpp
@@ -0,0 +1,116 @@
+#include "stdafx.h"
+#include "sciter-x.h"
+#include "sciter-x-behavior.h"
+
+#ifdef WINDOWS
+#ifndef THIS_HINSTANCE
+ EXTERN_C IMAGE_DOS_HEADER __ImageBase;
+ #define THIS_HINSTANCE ((HINSTANCE)&__ImageBase)
+#endif
+#endif
+
+using namespace std;
+
+namespace sciter
+{
+/*
+BEHAVIOR: native-clock
+ - draws content layer using sciter-x-graphics.hpp primitives.
+
+SAMPLE:
+ See: samples/behaviors/native-drawing.htm
+*/
+
+#ifdef WINDOWS
+
+struct native_textarea: public event_handler
+{
+ HWND this_hwnd;
+ HELEMENT this_element;
+ // ctor
+ native_textarea(): this_hwnd(0), this_element(0) {}
+ virtual ~native_textarea() {}
+
+ virtual bool subscription( HELEMENT he, UINT& event_groups )
+ {
+ event_groups = HANDLE_BEHAVIOR_EVENT | HANDLE_METHOD_CALL;
+ return true;
+ }
+
+ virtual void attached (HELEMENT he )
+ {
+ this_element = he;
+
+ dom::element self = dom::element::element(this_element);
+
+ RECT rc = self.get_location(VIEW_RELATIVE | CONTENT_BOX);
+
+ HWND parent = self.get_element_hwnd(false);
+
+ this_hwnd = ::CreateWindow(TEXT("EDIT"),
+ TEXT(""),
+ WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOHSCROLL | ES_WANTRETURN | ES_MULTILINE,
+ rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
+ parent, NULL, THIS_HINSTANCE, 0);
+
+ ::SendMessage(this_hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), true);
+
+ self.attach_hwnd(this_hwnd);
+ }
+ virtual void detached (HELEMENT he )
+ {
+ if (this_hwnd)
+ ::DestroyWindow(this_hwnd);
+ asset_release();
+ }
+
+ virtual bool handle_method_call(HELEMENT he, METHOD_PARAMS& params) {
+ switch (params.methodID)
+ {
+ case GET_VALUE:
+ {
+ VALUE_PARAMS* pvp = (VALUE_PARAMS*)(¶ms);
+ unsigned int length = ::GetWindowTextLength(this_hwnd);
+ wchar_t * buffer = new wchar_t[length];
+ ::GetWindowText(this_hwnd,buffer,length);
+ pvp->val = sciter::value(buffer, length);
+ delete[] buffer;
+ return true;
+ }
+ case SET_VALUE: {
+ VALUE_PARAMS* pvp = (VALUE_PARAMS*)(¶ms);
+ std::wstring text = pvp->val.to_string();
+ ::SetWindowText(this_hwnd, text.c_str());
+ return true;
+ }
+ }
+ return false;
+ }
+
+/* BEGIN_FUNCTION_MAP
+ FUNCTION_6("nativeGetPath", nativeGetPath);
+ FUNCTION_2("nativeImage", nativeImage);
+ END_FUNCTION_MAP */
+
+};
+#endif
+struct native_textarea_factory: public behavior_factory {
+
+ native_textarea_factory(): behavior_factory("native-textarea") { }
+
+ // the only behavior_factory method:
+ virtual event_handler* create(HELEMENT he) {
+#ifdef WINDOWS
+ return new native_textarea();
+#else
+ return nullptr;
+#endif
+ }
+
+};
+
+// instantiating and attaching it to the global list
+native_textarea_factory native_textarea_factory_instance;
+
+
+}
diff --git a/include/behaviors/behavior_tabs.cpp b/include/behaviors/behavior_tabs.cpp
new file mode 100644
index 0000000..b3dcca3
--- /dev/null
+++ b/include/behaviors/behavior_tabs.cpp
@@ -0,0 +1,290 @@
+#include "stdafx.h"
+#include "sciter-x.h"
+#include "sciter-x-behavior.h"
+
+namespace sciter
+{
+/*
+
+BEHAVIOR: tabs
+ goal: Implementation of the tabs: stacked panels switchable by tabs in tab strip
+COMMENTS:
+
+
+ - tab1 caption
+ - tab2 caption
+
+
first panel content
+
second panel content
+