From 9c66fcab3e941e8bbade55adbaddd5043e7edf13 Mon Sep 17 00:00:00 2001
From: cxl <cxl@f0d560ea-af0d-0410-9eb7-867de7ffcac7>
Date: Mon, 14 May 2012 14:47:25 +0000
Subject: [PATCH] Draw: Font, Drawing, Painting, Image now support Xmlize and
 Jsonize

git-svn-id: svn://ultimatepp.org/upp/trunk@4950 f0d560ea-af0d-0410-9eb7-867de7ffcac7
---
 uppsrc/Core/Color.h     |    2 +-
 uppsrc/Core/JSON.h      |   33 +
 uppsrc/Core/OldValue.h  |   14 +
 uppsrc/Core/Uuid.cpp    |    6 -
 uppsrc/Core/ValueUtil.h |  712 +++++++++----------
 uppsrc/Core/Xmlize.h    |    4 +-
 uppsrc/Draw/Draw.cpp    |    4 +-
 uppsrc/Draw/Draw.h      |   14 +-
 uppsrc/Draw/Drawing.cpp | 1384 ++++++++++++++++++------------------
 uppsrc/Draw/Font.cpp    |    4 +-
 uppsrc/Draw/Image.cpp   | 1470 +++++++++++++++++++--------------------
 uppsrc/Draw/Image.h     |  690 +++++++++---------
 uppsrc/Ole/util.h       |    2 +-
 uppsrc/Sql/Sqls.h       |    2 +-
 14 files changed, 2198 insertions(+), 2143 deletions(-)

diff --git a/uppsrc/Core/Color.h b/uppsrc/Core/Color.h
index 60cdf89b6..0af316a92 100644
--- a/uppsrc/Core/Color.h
+++ b/uppsrc/Core/Color.h
@@ -25,7 +25,7 @@ inline dword      RGB(byte r, byte g, byte b)    { return r | (g << 8) | (b << 1
 
 const int COLOR_V = 39;
 
-class Color : public AssignValueTypeNo<Color, COLOR_V, Moveable<Color> > {
+class Color : public ValueType<Color, COLOR_V, Moveable<Color> > {
 protected:
 	dword    color;
 
diff --git a/uppsrc/Core/JSON.h b/uppsrc/Core/JSON.h
index 5a1cd0404..e59fb158b 100644
--- a/uppsrc/Core/JSON.h
+++ b/uppsrc/Core/JSON.h
@@ -348,3 +348,36 @@ void Jsonize(JsonIO& io, ArrayIndex<T>& var)
 {
 	JsonizeIndex<ArrayIndex<T>, T>(io, var);
 }
+
+
+template <class T>
+void XmlizeBySerialize(XmlIO& xio, T& x)
+{
+	String h;
+	if(xio.IsStoring())
+	   h = HexString(StoreAsString(x));
+	xio.Attr("data", h);
+	if(xio.IsLoading())
+		try {
+			LoadFromString(x, ScanHexString(h));
+		}
+		catch(LoadingError) {
+			throw XmlError("xmlize by serialize error");
+		}
+}
+
+template <class T>
+void JsonizeBySerialize(JsonIO& jio, T& x)
+{
+	String h;
+	if(jio.IsStoring())
+	   h = HexString(StoreAsString(x));
+	jio("data", h);
+	if(jio.IsLoading())
+		try {
+			LoadFromString(x, ScanHexString(h));
+		}
+		catch(LoadingError) {
+			throw JsonizeError("jsonize by serialize error");
+		}
+}
diff --git a/uppsrc/Core/OldValue.h b/uppsrc/Core/OldValue.h
index 9c95c718c..c5963e9b5 100644
--- a/uppsrc/Core/OldValue.h
+++ b/uppsrc/Core/OldValue.h
@@ -148,6 +148,9 @@ public:
 
 	Value(Void *p)                        { ptr = p; }
 	const Void *GetVoidPtr() const        { return ptr; }
+	
+	template <class T> // Forward compatibility
+	static  void Register(const char *name = NULL);
 };
 
 #define VALUE_COMPARE(T) \
@@ -260,6 +263,11 @@ public:
 	void operator=(const AssignValueTypeNo&) {} // MSC 6.0 empty base class bug fix
 };
 
+template <class T, dword type, class B = EmptyClass> // Forward compatiblity
+class ValueType : public AssignValueTypeNo<T, type, B> {};
+
+
+
 template <class T>
 dword GetValueTypeNo() { return ValueTypeNo((T*)NULL); }
 
@@ -474,6 +482,12 @@ public:
 	}
 };
 
+template <class T>
+void Value::Register(const char *)
+{
+	RichValue<T>::Register();
+}
+
 template <class T>
 inline Value RichToValue(const T& data)                   { return RichValue<T>(data); }
 
diff --git a/uppsrc/Core/Uuid.cpp b/uppsrc/Core/Uuid.cpp
index 61b5751a3..a02a92299 100644
--- a/uppsrc/Core/Uuid.cpp
+++ b/uppsrc/Core/Uuid.cpp
@@ -4,15 +4,9 @@ NAMESPACE_UPP
 
 //#BLITZ_APPROVE
 
-#ifdef SVO_VALUE
 INITBLOCK {
 	Value::Register<Uuid>("Uuid");
 }
-#else
-INITBLOCK {
-	RichValue<Uuid>::Register();
-}
-#endif
 
 void Uuid::Serialize(Stream& s) {
 	int version = 0;
diff --git a/uppsrc/Core/ValueUtil.h b/uppsrc/Core/ValueUtil.h
index 666650cb7..86eda4fd9 100644
--- a/uppsrc/Core/ValueUtil.h
+++ b/uppsrc/Core/ValueUtil.h
@@ -1,357 +1,357 @@
-#ifdef SVO_VALUE
-
-Value Scan(dword stdtype, const String& text, const Value& def = Null);
-
-inline const String&  Nvl(const String& a, const String& b)    { return IsNull(a) ? b : a; }
-inline int            Nvl(int a, int b)                        { return IsNull(a) ? b : a; }
-inline int64          Nvl(int64 a, int64 b)                    { return IsNull(a) ? b : a; }
-inline double         Nvl(double a, double b)                  { return IsNull(a) ? b : a; }
-inline Date           Nvl(Date a, Date b)                      { return IsNull(a) ? b : a; }
-inline Time           Nvl(Time a, Time b)                      { return IsNull(a) ? b : a; }
-
-inline int            Nvl(int a)                               { return Nvl(a, 0); }
-inline int64          Nvl(int64 a)                             { return Nvl(a, (int64)0); }
-inline double         Nvl(double a)                            { return Nvl(a, 0.0); }
-
-int StdValueCompare(const Value& a, const Value& b, int language);
-int StdValueCompare(const Value& a, const Value& b);
-
-int StdValueCompareDesc(const Value& a, const Value& b, int language);
-int StdValueCompareDesc(const Value& a, const Value& b);
-
-struct ValueOrder {
-	virtual bool operator()(const Value& a, const Value& b) const = 0;
-	virtual ~ValueOrder() {}
-};
-
-struct StdValueOrder : ValueOrder {
-	int language;
-
-	virtual bool operator()(const Value& a, const Value& b) const;
-
-	StdValueOrder(int l = -1);
-};
-
-struct FnValueOrder : ValueOrder {
-	int (*fn)(const Value& a, const Value& b);
-
-	virtual bool operator()(const Value& a, const Value& b) const;
-
-	FnValueOrder(int (*fn)(const Value& a, const Value& b)) : fn(fn) {}
-};
-
-struct ValuePairOrder {
-	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const = 0;
-	virtual ~ValuePairOrder() {}
-};
-
-struct StdValuePairOrder : ValuePairOrder {
-	int language;
-
-	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
-
-	StdValuePairOrder(int l = -1);
-};
-
-struct FnValuePairOrder : ValuePairOrder {
-	int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2);
-
-	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
-
-	FnValuePairOrder(int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2)) : fn(fn) {}
-};
-
-class Id : Moveable<Id> {
-	String id;
-
-public:
-	const String&  ToString() const              { return id; }
-	dword          GetHashValue() const          { return UPP::GetHashValue(id); }
-	bool           IsNull() const                { return UPP::IsNull(id); }
-
-	operator const String&() const               { return ToString(); }
-	const String&  operator~() const             { return ToString(); }
-	bool           operator==(const Id& b) const { return id == b.id; }
-	bool           operator!=(const Id& b) const { return id != b.id; }
-
-	operator bool() const                        { return id.GetCount(); }
-
-	Id()                                         {}
-	Id(const String& s)                          { id = s; }
-	Id(const char *s)                            { id = s; }
-};
-
-struct RefManager {
-	virtual int   GetType() = 0;
-	virtual Value GetValue(const void *)            { return Null; }
-	virtual bool  IsNull(const void *)              { return false; }
-	virtual void  SetValue(void *, const Value& v)  { NEVER(); }
-	virtual void  SetNull(void *)                   { NEVER(); }
-	virtual ~RefManager() {}
-};
-
-template <class T>
-struct StdRef : public RefManager {
-	virtual void  SetValue(void *p, const Value& v) { *(T *) p = (T)v; }
-	virtual Value GetValue(const void *p)           { return *(const T *) p; }
-	virtual int   GetType()                         { return GetValueTypeNo<T>(); }
-	virtual bool  IsNull(const void *p)             { return UPP::IsNull(*(T *) p); }
-	virtual void  SetNull(void *p)                  { UPP::SetNull(*(T *)p); }
-	virtual ~StdRef() {}
-};
-
-class Ref : Moveable<Ref> {
-protected:
-	RefManager *m;
-	void       *ptr;
-	struct      ValueRef;
-
-public:
-	dword    GetType() const           { return m ? m->GetType() : VOID_V; }
-	bool     IsNull() const            { return m ? m->IsNull(ptr) : true; }
-
-	void    *GetVoidPtr() const        { return ptr; }
-
-	template <class T>
-	bool     Is() const                { return GetType() == GetValueTypeNo<T>(); } // VALUE_V!!!
-	template <class T>
-	T&       Get() const               { ASSERT(GetValueTypeNo<T>() == GetType()); return *(T *)GetVoidPtr(); }
-
-	void     SetNull()                 { if(m) m->SetNull(ptr); }
-	Value    GetValue() const          { return m ? m->GetValue(ptr) : Value(); }
-	void     SetValue(const Value& v)  { ASSERT(m); m->SetValue(ptr, v); }
-
-	operator Value() const             { return GetValue(); }
-	Value    operator~() const         { return GetValue(); }
-	Ref&     operator=(const Value& v) { SetValue(v); return *this; }
-
-	Ref(String& s);
-	Ref(WString& s);
-	Ref(int& i);
-	Ref(int64& i);
-	Ref(double& d);
-	Ref(bool& b);
-	Ref(Date& d);
-	Ref(Time& t);
-	Ref(Value& v);
-	Ref(void *_ptr, RefManager *_m)    { ptr = _ptr, m = _m; }
-	Ref(const ValueTypeRef& r);
-	Ref()                              { ptr = m = NULL; }
-};
-
-template <class T>
-T& GetRef(Ref r, T *x = NULL) {
-	ASSERT(GetValueTypeNo<T>() == r.GetType());
-	return *(T *) r.GetVoidPtr();
-}
-
-inline String&  RefString(Ref f)  { return GetRef<String>(f); }
-inline WString& RefWString(Ref f) { return GetRef<WString>(f); }
-inline int&     RefInt(Ref f)     { return GetRef<int>(f); }
-inline int64&   RefInt64(Ref f)   { return GetRef<int64>(f); }
-inline double&  RefDouble(Ref f)  { return GetRef<double>(f); }
-inline bool&    RefBool(Ref f)    { return GetRef<bool>(f); }
-inline Date&    RefDate(Ref f)    { return GetRef<Date>(f); }
-inline Time&    RefTime(Ref f)    { return GetRef<Time>(f); }
-inline Value&   RefValue(Ref f)   { ASSERT(f.GetType() == VALUE_V);
-                                    return *(Value *)f.GetVoidPtr(); }
-
-template <class T>
-Ref AsRef(T& x) {
-	return Ref(&x, &Single< StdRef<T> >());
-}
-
-struct ValueTypeRef {
-	RefManager *m;
-	void       *ptr;
-};
-
-inline
-Ref::Ref(const ValueTypeRef& r)
-{
-	ptr = r.ptr;
-	m = r.m;
-}
-
-template <class T, dword type, class B>
-ValueType<T, type, B>::operator ValueTypeRef()
-{
-	ValueTypeRef h;
-	h.ptr = this;
-	h.m = &Single< StdRef<T> >();
-	return h;
-}
-
-#define E__Value(I)   Value p##I
-#define E__Ref(I)     Ref p##I
-
-// ---------------------- Value Array
-
-class ValueArray : AssignValueTypeNo<ValueArray, VALUEARRAY_V, Moveable<ValueArray> > {
-	struct Data : Value::Void {
-		virtual dword      GetType() const             { return VALUEARRAY_V; }
-		virtual bool       IsNull() const;
-		virtual void       Serialize(Stream& s);
-		virtual void       Xmlize(XmlIO& xio);
-		virtual void       Jsonize(JsonIO& jio);
-		virtual unsigned   GetHashValue() const;
-		virtual bool       IsEqual(const Value::Void *p);
-		virtual String     AsString() const;
-
-		int GetRefCount() const     { return AtomicRead(refcount); }
-
-		Vector<Value> data;
-	};
-	struct NullData : Data {};
-	Data *data;
-
-	Vector<Value>& Create();
-	Vector<Value>& Clone();
-	void  Init0();
-	
-	friend Value::Void *ValueArrayDataCreate();
-	friend class Value;
-
-public:
-	ValueArray()                              { Init0(); }
-	ValueArray(const ValueArray& v);
-	explicit ValueArray(pick_ Vector<Value>& values);
-	explicit ValueArray(const Vector<Value>& values, int deep);
-	~ValueArray();
-
-	ValueArray& operator=(const ValueArray& v);
-
-	operator Value() const;
-	ValueArray(const Value& src);
-
-	ValueArray(const Nuller&)                 { Init0(); }
-	bool IsNullInstance() const               { return IsEmpty(); }
-
-	void Clear();
-	void SetCount(int n);
-	void SetCount(int n, const Value& v);
-	int  GetCount() const                     { return data->data.GetCount(); }
-	bool IsEmpty() const                      { return data->data.IsEmpty(); }
-
-	void Add(const Value& v);
-	ValueArray& operator<<(const Value& v)    { Add(v); return *this; }
-	void Set(int i, const Value& v);
-	const Value& Get(int i) const;
-	Value GetAndClear(int i);
-	const Vector<Value>& Get() const          { return data->data; }
-
-	void Remove(int i, int count = 1);
-	void Insert(int i, const ValueArray& va);
-	void Append(const ValueArray& va)         { Insert(GetCount(), va); }
-
-	const Value& operator[](int i) const      { return Get(i); }
-
-	unsigned GetHashValue() const             { return data->GetHashValue(); }
-	void     Serialize(Stream& s);
-	void     Jsonize(JsonIO& jio);
-	String   ToString() const;
-
-	bool operator==(const ValueArray& v) const;
-	bool operator!=(const ValueArray& v) const  { return !operator==(v); }
-};
-
-template<>
-String AsString(const ValueArray& v);
-
-class ValueMap : AssignValueTypeNo<ValueMap, VALUEMAP_V, Moveable<ValueMap> >{
-	struct Data : Value::Void {
-		virtual dword      GetType() const             { return VALUEMAP_V; }
-		virtual bool       IsNull() const;
-		virtual void       Serialize(Stream& s);
-		virtual void       Xmlize(XmlIO& xio);
-		virtual void       Jsonize(JsonIO& jio);
-		virtual unsigned   GetHashValue() const;
-		virtual bool       IsEqual(const Value::Void *p);
-		virtual String     AsString() const;
-
-		const Value& Get(const Value& key) const;
-
-		Index<Value> key;
-		ValueArray   value;
-	};
-
-	struct NullData : Data {};
-	Data *data;
-
-	Data& Create();
-	Data& Clone();
-	void  Init0();
-
-	friend Value::Void *ValueMapDataCreate();
-	friend class Value;
-
-public:
-	ValueMap()                               { Init0(); }
-	ValueMap(const ValueMap& v);
-	ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v);
-	ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep);
-	~ValueMap();
-
-	ValueMap& operator=(const ValueMap& v);
-
-	operator Value() const;
-	ValueMap(const Value& src);
-
-	ValueMap(const Nuller&)                  { Init0(); }
-	bool IsNullInstance() const              { return IsEmpty(); }
-
-	void Clear();
-	int  GetCount() const                     { return data->value.GetCount(); }
-	bool IsEmpty() const                      { return data->value.IsEmpty(); }
-	const Value& GetKey(int i) const          { return data->key[i]; }
-	const Value& GetValue(int i) const        { return data->value[i]; }
-
-	void Add(const Value& key, const Value& value);
-	void Add(const String& s, const Value& value) { Add(Value(s), value); }
-	void Add(const char *s, const Value& value)   { Add(Value(s), value); }
-	void Add(Id id, const Value& value)           { Add(Value(id.ToString()), value); }
-
-	void Set(const Value& key, const Value& value);
-	void Set(const String& s, const Value& value) { Set(Value(s), value); }
-	void Set(const char *s, const Value& value)   { Set(Value(s), value); }
-	void Set(Id id, const Value& value)           { Set(Value(id.ToString()), value); }
-
-	void SetAt(int i, const Value& v);
-	void SetKey(int i, const Value& k);
-	void SetKey(int i, const String& s)           { SetKey(i, Value(s)); }
-	void SetKey(int i, const char* s)             { SetKey(i, Value(s)); }
-	void SetKey(int i, Id id)                     { SetKey(i, Value(id.ToString())); }
-	void Remove(int i);
-
-	const Index<Value>& GetKeys() const           { return data->key; }
-	ValueArray GetValues() const                  { return data->value; }
-
-	operator ValueArray() const                   { return GetValues(); }
-
-	const Value& operator[](const Value& k) const;
-	const Value& operator[](const String& s) const{ return operator[](Value(s)); }
-	const Value& operator[](const char *s) const  { return operator[](Value(s)); }
-	const Value& operator[](const Id& k) const    { return operator[](Value(k.ToString())); }
-	
-	Value GetAndClear(const Value& key);
-
-	unsigned GetHashValue() const                 { return data->GetHashValue(); }
-	void     Serialize(Stream& s);
-	void     Jsonize(JsonIO& jio);
-	String   ToString() const                     { return data->AsString(); }
-
-	bool operator==(const ValueMap& v) const;
-	bool operator!=(const ValueMap& v) const      { return !operator==(v); }
-};
-
-class ValueGen {
-public:
-	virtual Value  Get() = 0;
-	Value operator++()                           { return Get(); }
-	virtual ~ValueGen() {}
-};
-
-
-#include "Value.hpp"
-
+#ifdef SVO_VALUE
+
+Value Scan(dword stdtype, const String& text, const Value& def = Null);
+
+inline const String&  Nvl(const String& a, const String& b)    { return IsNull(a) ? b : a; }
+inline int            Nvl(int a, int b)                        { return IsNull(a) ? b : a; }
+inline int64          Nvl(int64 a, int64 b)                    { return IsNull(a) ? b : a; }
+inline double         Nvl(double a, double b)                  { return IsNull(a) ? b : a; }
+inline Date           Nvl(Date a, Date b)                      { return IsNull(a) ? b : a; }
+inline Time           Nvl(Time a, Time b)                      { return IsNull(a) ? b : a; }
+
+inline int            Nvl(int a)                               { return Nvl(a, 0); }
+inline int64          Nvl(int64 a)                             { return Nvl(a, (int64)0); }
+inline double         Nvl(double a)                            { return Nvl(a, 0.0); }
+
+int StdValueCompare(const Value& a, const Value& b, int language);
+int StdValueCompare(const Value& a, const Value& b);
+
+int StdValueCompareDesc(const Value& a, const Value& b, int language);
+int StdValueCompareDesc(const Value& a, const Value& b);
+
+struct ValueOrder {
+	virtual bool operator()(const Value& a, const Value& b) const = 0;
+	virtual ~ValueOrder() {}
+};
+
+struct StdValueOrder : ValueOrder {
+	int language;
+
+	virtual bool operator()(const Value& a, const Value& b) const;
+
+	StdValueOrder(int l = -1);
+};
+
+struct FnValueOrder : ValueOrder {
+	int (*fn)(const Value& a, const Value& b);
+
+	virtual bool operator()(const Value& a, const Value& b) const;
+
+	FnValueOrder(int (*fn)(const Value& a, const Value& b)) : fn(fn) {}
+};
+
+struct ValuePairOrder {
+	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const = 0;
+	virtual ~ValuePairOrder() {}
+};
+
+struct StdValuePairOrder : ValuePairOrder {
+	int language;
+
+	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
+
+	StdValuePairOrder(int l = -1);
+};
+
+struct FnValuePairOrder : ValuePairOrder {
+	int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2);
+
+	virtual bool operator()(const Value& keya, const Value& valuea, const Value& keyb, const Value& valueb) const;
+
+	FnValuePairOrder(int (*fn)(const Value& k1, const Value& v1, const Value& k2, const Value& v2)) : fn(fn) {}
+};
+
+class Id : Moveable<Id> {
+	String id;
+
+public:
+	const String&  ToString() const              { return id; }
+	dword          GetHashValue() const          { return UPP::GetHashValue(id); }
+	bool           IsNull() const                { return UPP::IsNull(id); }
+
+	operator const String&() const               { return ToString(); }
+	const String&  operator~() const             { return ToString(); }
+	bool           operator==(const Id& b) const { return id == b.id; }
+	bool           operator!=(const Id& b) const { return id != b.id; }
+
+	operator bool() const                        { return id.GetCount(); }
+
+	Id()                                         {}
+	Id(const String& s)                          { id = s; }
+	Id(const char *s)                            { id = s; }
+};
+
+struct RefManager {
+	virtual int   GetType() = 0;
+	virtual Value GetValue(const void *)            { return Null; }
+	virtual bool  IsNull(const void *)              { return false; }
+	virtual void  SetValue(void *, const Value& v)  { NEVER(); }
+	virtual void  SetNull(void *)                   { NEVER(); }
+	virtual ~RefManager() {}
+};
+
+template <class T>
+struct StdRef : public RefManager {
+	virtual void  SetValue(void *p, const Value& v) { *(T *) p = (T)v; }
+	virtual Value GetValue(const void *p)           { return *(const T *) p; }
+	virtual int   GetType()                         { return GetValueTypeNo<T>(); }
+	virtual bool  IsNull(const void *p)             { return UPP::IsNull(*(T *) p); }
+	virtual void  SetNull(void *p)                  { UPP::SetNull(*(T *)p); }
+	virtual ~StdRef() {}
+};
+
+class Ref : Moveable<Ref> {
+protected:
+	RefManager *m;
+	void       *ptr;
+	struct      ValueRef;
+
+public:
+	dword    GetType() const           { return m ? m->GetType() : VOID_V; }
+	bool     IsNull() const            { return m ? m->IsNull(ptr) : true; }
+
+	void    *GetVoidPtr() const        { return ptr; }
+
+	template <class T>
+	bool     Is() const                { return GetType() == GetValueTypeNo<T>(); } // VALUE_V!!!
+	template <class T>
+	T&       Get() const               { ASSERT(GetValueTypeNo<T>() == GetType()); return *(T *)GetVoidPtr(); }
+
+	void     SetNull()                 { if(m) m->SetNull(ptr); }
+	Value    GetValue() const          { return m ? m->GetValue(ptr) : Value(); }
+	void     SetValue(const Value& v)  { ASSERT(m); m->SetValue(ptr, v); }
+
+	operator Value() const             { return GetValue(); }
+	Value    operator~() const         { return GetValue(); }
+	Ref&     operator=(const Value& v) { SetValue(v); return *this; }
+
+	Ref(String& s);
+	Ref(WString& s);
+	Ref(int& i);
+	Ref(int64& i);
+	Ref(double& d);
+	Ref(bool& b);
+	Ref(Date& d);
+	Ref(Time& t);
+	Ref(Value& v);
+	Ref(void *_ptr, RefManager *_m)    { ptr = _ptr, m = _m; }
+	Ref(const ValueTypeRef& r);
+	Ref()                              { ptr = m = NULL; }
+};
+
+template <class T>
+T& GetRef(Ref r, T *x = NULL) {
+	ASSERT(GetValueTypeNo<T>() == r.GetType());
+	return *(T *) r.GetVoidPtr();
+}
+
+inline String&  RefString(Ref f)  { return GetRef<String>(f); }
+inline WString& RefWString(Ref f) { return GetRef<WString>(f); }
+inline int&     RefInt(Ref f)     { return GetRef<int>(f); }
+inline int64&   RefInt64(Ref f)   { return GetRef<int64>(f); }
+inline double&  RefDouble(Ref f)  { return GetRef<double>(f); }
+inline bool&    RefBool(Ref f)    { return GetRef<bool>(f); }
+inline Date&    RefDate(Ref f)    { return GetRef<Date>(f); }
+inline Time&    RefTime(Ref f)    { return GetRef<Time>(f); }
+inline Value&   RefValue(Ref f)   { ASSERT(f.GetType() == VALUE_V);
+                                    return *(Value *)f.GetVoidPtr(); }
+
+template <class T>
+Ref AsRef(T& x) {
+	return Ref(&x, &Single< StdRef<T> >());
+}
+
+struct ValueTypeRef {
+	RefManager *m;
+	void       *ptr;
+};
+
+inline
+Ref::Ref(const ValueTypeRef& r)
+{
+	ptr = r.ptr;
+	m = r.m;
+}
+
+template <class T, dword type, class B>
+ValueType<T, type, B>::operator ValueTypeRef()
+{
+	ValueTypeRef h;
+	h.ptr = this;
+	h.m = &Single< StdRef<T> >();
+	return h;
+}
+
+#define E__Value(I)   Value p##I
+#define E__Ref(I)     Ref p##I
+
+// ---------------------- Value Array
+
+class ValueArray : ValueType<ValueArray, VALUEARRAY_V, Moveable<ValueArray> > {
+	struct Data : Value::Void {
+		virtual dword      GetType() const             { return VALUEARRAY_V; }
+		virtual bool       IsNull() const;
+		virtual void       Serialize(Stream& s);
+		virtual void       Xmlize(XmlIO& xio);
+		virtual void       Jsonize(JsonIO& jio);
+		virtual unsigned   GetHashValue() const;
+		virtual bool       IsEqual(const Value::Void *p);
+		virtual String     AsString() const;
+
+		int GetRefCount() const     { return AtomicRead(refcount); }
+
+		Vector<Value> data;
+	};
+	struct NullData : Data {};
+	Data *data;
+
+	Vector<Value>& Create();
+	Vector<Value>& Clone();
+	void  Init0();
+	
+	friend Value::Void *ValueArrayDataCreate();
+	friend class Value;
+
+public:
+	ValueArray()                              { Init0(); }
+	ValueArray(const ValueArray& v);
+	explicit ValueArray(pick_ Vector<Value>& values);
+	explicit ValueArray(const Vector<Value>& values, int deep);
+	~ValueArray();
+
+	ValueArray& operator=(const ValueArray& v);
+
+	operator Value() const;
+	ValueArray(const Value& src);
+
+	ValueArray(const Nuller&)                 { Init0(); }
+	bool IsNullInstance() const               { return IsEmpty(); }
+
+	void Clear();
+	void SetCount(int n);
+	void SetCount(int n, const Value& v);
+	int  GetCount() const                     { return data->data.GetCount(); }
+	bool IsEmpty() const                      { return data->data.IsEmpty(); }
+
+	void Add(const Value& v);
+	ValueArray& operator<<(const Value& v)    { Add(v); return *this; }
+	void Set(int i, const Value& v);
+	const Value& Get(int i) const;
+	Value GetAndClear(int i);
+	const Vector<Value>& Get() const          { return data->data; }
+
+	void Remove(int i, int count = 1);
+	void Insert(int i, const ValueArray& va);
+	void Append(const ValueArray& va)         { Insert(GetCount(), va); }
+
+	const Value& operator[](int i) const      { return Get(i); }
+
+	unsigned GetHashValue() const             { return data->GetHashValue(); }
+	void     Serialize(Stream& s);
+	void     Jsonize(JsonIO& jio);
+	String   ToString() const;
+
+	bool operator==(const ValueArray& v) const;
+	bool operator!=(const ValueArray& v) const  { return !operator==(v); }
+};
+
+template<>
+String AsString(const ValueArray& v);
+
+class ValueMap : ValueType<ValueMap, VALUEMAP_V, Moveable<ValueMap> >{
+	struct Data : Value::Void {
+		virtual dword      GetType() const             { return VALUEMAP_V; }
+		virtual bool       IsNull() const;
+		virtual void       Serialize(Stream& s);
+		virtual void       Xmlize(XmlIO& xio);
+		virtual void       Jsonize(JsonIO& jio);
+		virtual unsigned   GetHashValue() const;
+		virtual bool       IsEqual(const Value::Void *p);
+		virtual String     AsString() const;
+
+		const Value& Get(const Value& key) const;
+
+		Index<Value> key;
+		ValueArray   value;
+	};
+
+	struct NullData : Data {};
+	Data *data;
+
+	Data& Create();
+	Data& Clone();
+	void  Init0();
+
+	friend Value::Void *ValueMapDataCreate();
+	friend class Value;
+
+public:
+	ValueMap()                               { Init0(); }
+	ValueMap(const ValueMap& v);
+	ValueMap(pick_ Index<Value>& k, pick_ Vector<Value>& v);
+	ValueMap(const Index<Value>& k, const Vector<Value>& v, int deep);
+	~ValueMap();
+
+	ValueMap& operator=(const ValueMap& v);
+
+	operator Value() const;
+	ValueMap(const Value& src);
+
+	ValueMap(const Nuller&)                  { Init0(); }
+	bool IsNullInstance() const              { return IsEmpty(); }
+
+	void Clear();
+	int  GetCount() const                     { return data->value.GetCount(); }
+	bool IsEmpty() const                      { return data->value.IsEmpty(); }
+	const Value& GetKey(int i) const          { return data->key[i]; }
+	const Value& GetValue(int i) const        { return data->value[i]; }
+
+	void Add(const Value& key, const Value& value);
+	void Add(const String& s, const Value& value) { Add(Value(s), value); }
+	void Add(const char *s, const Value& value)   { Add(Value(s), value); }
+	void Add(Id id, const Value& value)           { Add(Value(id.ToString()), value); }
+
+	void Set(const Value& key, const Value& value);
+	void Set(const String& s, const Value& value) { Set(Value(s), value); }
+	void Set(const char *s, const Value& value)   { Set(Value(s), value); }
+	void Set(Id id, const Value& value)           { Set(Value(id.ToString()), value); }
+
+	void SetAt(int i, const Value& v);
+	void SetKey(int i, const Value& k);
+	void SetKey(int i, const String& s)           { SetKey(i, Value(s)); }
+	void SetKey(int i, const char* s)             { SetKey(i, Value(s)); }
+	void SetKey(int i, Id id)                     { SetKey(i, Value(id.ToString())); }
+	void Remove(int i);
+
+	const Index<Value>& GetKeys() const           { return data->key; }
+	ValueArray GetValues() const                  { return data->value; }
+
+	operator ValueArray() const                   { return GetValues(); }
+
+	const Value& operator[](const Value& k) const;
+	const Value& operator[](const String& s) const{ return operator[](Value(s)); }
+	const Value& operator[](const char *s) const  { return operator[](Value(s)); }
+	const Value& operator[](const Id& k) const    { return operator[](Value(k.ToString())); }
+	
+	Value GetAndClear(const Value& key);
+
+	unsigned GetHashValue() const                 { return data->GetHashValue(); }
+	void     Serialize(Stream& s);
+	void     Jsonize(JsonIO& jio);
+	String   ToString() const                     { return data->AsString(); }
+
+	bool operator==(const ValueMap& v) const;
+	bool operator!=(const ValueMap& v) const      { return !operator==(v); }
+};
+
+class ValueGen {
+public:
+	virtual Value  Get() = 0;
+	Value operator++()                           { return Get(); }
+	virtual ~ValueGen() {}
+};
+
+
+#include "Value.hpp"
+
 #endif
\ No newline at end of file
diff --git a/uppsrc/Core/Xmlize.h b/uppsrc/Core/Xmlize.h
index 97ac7cd07..aff43cf73 100644
--- a/uppsrc/Core/Xmlize.h
+++ b/uppsrc/Core/Xmlize.h
@@ -290,9 +290,9 @@ String StoreAsXML(Callback1<XmlIO> xmlize, const char *name);
 bool   LoadFromXML(Callback1<XmlIO> xmlize, const String& xml);
 
 template <class T>
-String StoreAsXML(T& data, const char *name)
+String StoreAsXML(const T& data, const char *name)
 {
-	ParamHelper__<T> p(data);
+	ParamHelper__<T> p(const_cast<T &>(data));
 	return StoreAsXML(callback(&p, &ParamHelper__<T>::Invoke), name);
 }
 
diff --git a/uppsrc/Draw/Draw.cpp b/uppsrc/Draw/Draw.cpp
index 3f2e7dde5..4f036a9e0 100644
--- a/uppsrc/Draw/Draw.cpp
+++ b/uppsrc/Draw/Draw.cpp
@@ -9,8 +9,8 @@ NAMESPACE_UPP
 static StaticMutex sDrawLock;
 
 INITBLOCK {
-	RichValue<Painting>::Register();
-	RichValue<Drawing>::Register();
+	Value::Register<Painting>("Painting");
+	Value::Register<Drawing>("Drawing");
 }
 
 void Draw::SinCos(int angle, double& sina, double& cosa)
diff --git a/uppsrc/Draw/Draw.h b/uppsrc/Draw/Draw.h
index f2b5b179a..87a52b01f 100644
--- a/uppsrc/Draw/Draw.h
+++ b/uppsrc/Draw/Draw.h
@@ -43,7 +43,7 @@ const int FONT_V = 40;
 
 class FontInfo;
 
-class Font : public AssignValueTypeNo<Font, FONT_V, Moveable<Font> >{
+class Font : public ValueType<Font, FONT_V, Moveable<Font> >{
 	union {
 		int64 data;
 		struct {
@@ -373,7 +373,7 @@ void SColorDkShadow_Write(Color c);
 inline Color InvertColor() { return Color(255, 0); }
 inline Color DefaultInk() { return Black(); } //TODO!
 
-class Painting : public AssignValueTypeNo<Painting, 48, Moveable<Painting> > {
+class Painting : public ValueType<Painting, 48, Moveable<Painting> > {
 	String     cmd;
 	ValueArray data;
 	Sizef      size;
@@ -386,6 +386,10 @@ public:
 
 	void    Clear()                             { size = Null; data.Clear(); cmd.Clear(); }
 	void    Serialize(Stream& s)                { s % cmd % data % size; }
+#ifdef SVO_VALUE
+	void Xmlize(XmlIO& xio)                     { XmlizeBySerialize(xio, *this); }
+	void Jsonize(JsonIO& jio)                   { JsonizeBySerialize(jio, *this); }
+#endif
 	bool    IsNullInstance() const              { return cmd.IsEmpty(); }
 	void    SetNull()                           { size = Null; }
 	bool    operator==(const Painting& b) const { return cmd == b.cmd && data == b.data && size == b.size; }
@@ -624,7 +628,7 @@ public:
 	template <class T>	static void Register(const char *id)  { AddFormat(id, &DataDrawer::FactoryFn<T>); }
 };
 
-class Drawing : public AssignValueTypeNo<Drawing, 49, Moveable<Drawing> > {
+class Drawing : public ValueType<Drawing, 49, Moveable<Drawing> > {
 	Size       size;
 	String     data;
 	ValueArray val;
@@ -646,6 +650,10 @@ public:
 	void Append(Drawing& dw);
 
 	void Serialize(Stream& s);
+#ifdef SVO_VALUE
+	void Xmlize(XmlIO& xio)        { XmlizeBySerialize(xio, *this); }
+	void Jsonize(JsonIO& jio)      { JsonizeBySerialize(jio, *this); }
+#endif
 
 	bool    IsNullInstance() const             { return data.IsEmpty(); }
 	void    SetNull()                          { size = Null; }
diff --git a/uppsrc/Draw/Drawing.cpp b/uppsrc/Draw/Drawing.cpp
index 3a8158c18..38a97c18b 100644
--- a/uppsrc/Draw/Drawing.cpp
+++ b/uppsrc/Draw/Drawing.cpp
@@ -1,692 +1,692 @@
-#include "Draw.h"
-
-NAMESPACE_UPP
-
-enum {
-	DRAWING_BEGIN               = 1,
-	DRAWING_OFFSET              = 2,
-	DRAWING_CLIP                = 3,
-	DRAWING_CLIPOFF             = 4,
-	DRAWING_EXCLUDECLIP         = 5,
-	DRAWING_INTERSECTCLIP       = 6,
-	DRAWING_END                 = 7,
-	DRAWING_DRAWRECT            = 8,
-	DRAWING_DRAWIMAGE           = 9,
-	DRAWING_DRAWMONOIMAGE       = 10,
-	DRAWING_DRAWDRAWING         = 11,
-	DRAWING_DRAWLINE            = 12,
-	DRAWING_DRAWELLIPSE         = 13,
-	DRAWING_DRAWTEXT            = 14,
-	DRAWING_DRAWARC             = 15,
-	DRAWING_DRAWPOLYPOLYLINE    = 16,
-	DRAWING_DRAWPOLYPOLYPOLYGON = 17,
-	DRAWING_DRAWDATA            = 18,
-	DRAWING_DRAWPAINTING        = 19,
-};
-
-
-#define LLOG(x)  // DLOG(x)
-
-#ifdef COMPILER_MSC
-#pragma warning(disable: 4700)
-#endif
-
-static void StreamUnpackPoints(Stream& stream, Point *out, int count)
-{
-	if(count == 0)
-		return;
-#ifdef CPU_LITTLE_ENDIAN
-	if(sizeof(Point) == 8) {
-		stream.Get(out, 8 * count);
-		return;
-	}
-#endif
-	Point *end = out + count;
-	byte *top = reinterpret_cast<byte *>(end) - count * 8;
-	stream.Get(top, count * 8);
-	for(; out < end; out++, top += 8) {
-		out -> x = (short)Peek32le(top + 0);
-		out -> y = (short)Peek32le(top + 4);
-	}
-}
-
-static void StreamPackPoints(Stream& stream, const Point *in, int count)
-{
-#ifdef CPU_LITTLE_ENDIAN
-	if(sizeof(Point) == 8) {
-		stream.Put(in, 8 * count);
-		return;
-	}
-#endif
-	enum { PART = 1024 };
-	byte part[PART * 8];
-	while(count > 0)
-	{
-		int part_count = min<int>(count, PART);
-		for(byte *pp = part, *pe = pp + 8 * part_count; pp < pe; pp += 8, in++) {
-			Poke32le(pp + 0, in -> x);
-			Poke32le(pp + 4, in -> y);
-		}
-		stream.Put(part, part_count * 4);
-		count -= part_count;
-	}
-}
-
-static void StreamUnpackInts(Stream& stream, int *out, int count)
-{
-#ifdef CPU_LITTLE_ENDIAN
-	if(sizeof(int) == 4) {
-		stream.Get(out, count * 4);
-		return;
-	}
-#endif
-	while(count--)
-		*out++ = stream.Get32le();
-}
-
-static void StreamPackInts(Stream& stream, const int *in, int count)
-{
-#ifdef CPU_LITTLE_ENDIAN
-	if(sizeof(int) == 4) {
-		stream.Put(in, count * 4);
-		return;
-	}
-#endif
-	while(count--)
-		stream.Put32le(*in++);
-}
-
-// ------------------------------
-
-Stream& DrawingDraw::DrawingOp(int code)
-{
-	drawing / code;
-	return drawing;
-}
-
-dword DrawingDraw::GetInfo() const
-{
-	return dots ? DOTS : 0;
-}
-
-Size DrawingDraw::GetPageSize() const
-{
-	return size;
-}
-
-Rect DrawingDraw::GetPaintRect() const
-{
-	return Rect(size);
-}
-
-void DrawingDraw::BeginOp()
-{
-	DrawingOp(DRAWING_BEGIN);
-}
-
-void DrawingDraw::OffsetOp(Point p)
-{
-	DrawingOp(DRAWING_OFFSET) % p;
-}
-
-bool DrawingDraw::ClipOp(const Rect& r)
-{
-	DrawingOp(DRAWING_CLIP) % const_cast<Rect&>(r);
-	return true;
-}
-
-bool DrawingDraw::ClipoffOp(const Rect& r)
-{
-	DrawingOp(DRAWING_CLIPOFF) % const_cast<Rect&>(r);
-	return true;
-}
-
-void DrawingDraw::EndOp()
-{
-	DrawingOp(DRAWING_END);
-}
-
-bool DrawingDraw::ExcludeClipOp(const Rect& r)
-{
-	DrawingOp(DRAWING_EXCLUDECLIP) % const_cast<Rect&>(r);
-	return true;
-}
-
-bool DrawingDraw::IntersectClipOp(const Rect& r)
-{
-	DrawingOp(DRAWING_INTERSECTCLIP) % const_cast<Rect&>(r);
-	return true;
-}
-
-bool DrawingDraw::IsPaintingOp(const Rect& r) const
-{
-	return true;
-}
-
-void DrawingDraw::DrawRectOp(int x, int y, int cx, int cy, Color color)
-{
-	if(!IsNull(color))
-		DrawingOp(DRAWING_DRAWRECT) % x % y % cx % cy % color;
-}
-
-void DrawingDraw::DrawImageOp(int x, int y, int cx, int cy, const Image& img, const Rect& src, Color color)
-{
-	Rect s = src;
-	DrawingOp(DRAWING_DRAWIMAGE) % x % y % cx % cy % s % color;
-	val.Add(img);
-}
-
-void DrawingDraw::DrawDataOp(int x, int y, int cx, int cy, const String& data, const char *id)
-{
-	String h = id;
-	DrawingOp(DRAWING_DRAWDATA) % x % y % cx % cy % h;
-	val.Add(data);
-}
-
-void DrawingDraw::DrawDrawingOp(const Rect& target, const Drawing& w)
-{
-	DrawingOp(DRAWING_DRAWDRAWING) % const_cast<Rect&>(target);
-	val.Add(w);
-}
-
-void DrawingDraw::DrawPaintingOp(const Rect& target, const Painting& w)
-{
-	DrawingOp(DRAWING_DRAWPAINTING) % const_cast<Rect&>(target);
-	val.Add(w);
-}
-
-void DrawingDraw::DrawLineOp(int x1, int y1, int x2, int y2, int width, Color color)
-{
-	DrawingOp(DRAWING_DRAWLINE) % x1 % y1 % x2 % y2 % width % color;
-}
-
-void DrawingDraw::DrawPolyPolylineOp(const Point *vertices, int vertex_count,
-	                                 const int *counts, int count_count,
-	                                 int width, Color color, Color doxor)
-{
-	ASSERT(count_count > 0 && vertex_count > 0);
-	if(vertex_count < 2 || IsNull(color))
-		return;
-	DrawingOp(DRAWING_DRAWPOLYPOLYLINE);
-	int version = 2;
-	drawing / version;
-	drawing % width % color % doxor;
-	drawing % vertex_count % count_count;
-	StreamPackPoints(drawing, vertices, vertex_count);
-	StreamPackInts(drawing, counts, count_count);
-}
-
-void DrawingDraw::DrawPolyPolyPolygonOp(const Point *vertices, int vertex_count,
-	                   const int *subpolygon_counts, int subpolygon_count_count,
-	                   const int *disjunct_polygon_counts, int disjunct_polygon_count_count,
-	                   Color color, int width, Color outline, uint64 pattern, Color doxor)
-{
-	if(vertex_count == 0)
-		return;
-	DrawingOp(DRAWING_DRAWPOLYPOLYPOLYGON);
-	int version = 2;
-	drawing / version;
-	drawing % color % width % outline % pattern % doxor;
-	drawing % vertex_count % subpolygon_count_count % disjunct_polygon_count_count;
-	StreamPackPoints(drawing, vertices, vertex_count);
-	StreamPackInts(drawing, subpolygon_counts, subpolygon_count_count);
-	StreamPackInts(drawing, disjunct_polygon_counts, disjunct_polygon_count_count);
-}
-
-void DrawingDraw::DrawEllipseOp(const Rect& r, Color color, int pen, Color pencolor)
-{
-	DrawingOp(DRAWING_DRAWELLIPSE) % const_cast<Rect&>(r) % color / pen % pencolor;
-}
-
-void DrawingDraw::DrawArcOp(const Rect& rc, Point start, Point end, int width, Color color)
-{
-	DrawingOp(DRAWING_DRAWARC) % const_cast<Rect&>(rc) % start % end % color % width;
-}
-
-void DrawingDraw::DrawTextOp(int x, int y, int angle, const wchar *text, Font font, Color ink,
-                             int n, const int *dx) {
-	if(IsNull(ink)) return;
-	if(n < 0)
-		n = wstrlen((const wchar *)text);
-	if(n == 0)
-		return;
-	Stream& s = DrawingOp(DRAWING_DRAWTEXT);
-	byte cs = CHARSET_UNICODE;
-	s % x % y % angle % font % ink / n % cs;
-	s.PutW((wchar *)text, n);
-	bool dxb = dx;
-	s % dxb;
-	if(dx) {
-		int *w = const_cast<int *>(dx);
-		while(n--)
-			s / *w++;
-	}
-}
-
-Drawing DrawingDraw::GetResult()
-{
-	Drawing out;
-	out.size = size;
-	LLOG("GetResult size: " << size);
-	out.data = drawing.GetResult();
-	out.val = val;
-	return out;
-}
-
-// ------------------------------
-
-struct Draw::DrawingPos : StringStream {
-	Size    source;
-	Size    target;
-	Point   srcoff;
-	Point   trgoff;
-
-	Vector<Point> stk;
-
-	bool  Identity() const                               { return source == target; }
-
-	int   GetX(int x) const;
-	int   GetY(int y) const;
-	int   GetCx(int cx) const;
-	int   GetCy(int cy) const;
-	int   GetW(int w) const;
-	Point Get(int x, int y) const;
-	Point Get(Point p) const;
-	Rect  Get(const Rect& r) const;
-	Rect  Get(int x, int y, int cx, int cy) const;
-
-	Point operator()(int x, int y) const                 { return Get(x, y); }
-	Point operator()(Point p) const                      { return Get(p); }
-	Rect  operator()(const Rect& r) const                { return Get(r); }
-	Rect  operator()(int x, int y, int cx, int cy) const { return Get(x, y, cx, cy); }
-
-	void TransformX(int& x) const                        { x = GetX(x); }
-	void TransformY(int& y) const                        { y = GetY(y); }
-	void TransformW(int& w) const                        { w = GetW(w); }
-	void Transform(int& x, int& y) const                 { TransformX(x); TransformY(y); }
-	void Transform(Point& p) const                       { p = Get(p); }
-	void Transform(Rect& r) const                        { r = Get(r); }
-	
-	Rect  GetRect();
-	
-	void  Push();
-	void  Pop();
-	
-	DrawingPos(const String& src) : StringStream(src) {}
-};
-
-void Draw::DrawingPos::Push()
-{
-	stk.Add(srcoff);
-	stk.Add(trgoff);
-}
-
-void Draw::DrawingPos::Pop()
-{
-	trgoff = stk.Pop();
-	srcoff = stk.Pop();
-}
-
-Rect Draw::DrawingPos::GetRect()
-{
-	Rect r;
-	*this % r;
-	return Get(r);
-}
-
-int   Draw::DrawingPos::GetX(int x) const {
-	return iscale(x + srcoff.x, target.cx, source.cx) - trgoff.x;
-}
-
-int   Draw::DrawingPos::GetY(int y) const {
-	return iscale(y + srcoff.y, target.cy, source.cy) - trgoff.y;
-}
-
-int   Draw::DrawingPos::GetCx(int cx) const {
-	return iscale(cx, target.cx, source.cx);
-}
-
-int   Draw::DrawingPos::GetCy(int cy) const {
-	return iscale(cy, target.cy, source.cy);
-}
-
-int   Draw::DrawingPos::GetW(int w) const {
-	return iscale(w, target.cx + target.cy, source.cx + source.cy);
-}
-
-Point Draw::DrawingPos::Get(int x, int y) const {
-	return Point(GetX(x), GetY(y));
-}
-
-Point Draw::DrawingPos::Get(Point p) const {
-	return Get(p.x, p.y);
-}
-
-Rect  Draw::DrawingPos::Get(const Rect& r) const {
-	return Rect(GetX(r.left), GetY(r.top), GetX(r.right), GetY(r.bottom));
-}
-
-Rect  Draw::DrawingPos::Get(int x, int y, int cx, int cy) const {
-	return Get(RectC(x, y, cx, cy));
-}
-
-void Draw::DrawDrawingOp(const Rect& target, const Drawing& w) {
-#ifdef _DEBUG
-	int cl = GetCloffLevel();
-#endif
-	DrawingPos ps(w.data);
-	ps.srcoff = ps.trgoff = Point(0, 0);
-	ps.target = target.Size();
-	ps.source = w.size;
-	LLOG("DrawDrawingOp size: " << w.size);
-	if(ps.target.cx == 0 || ps.target.cy == 0 || ps.source.cx == 0 || ps.source.cy == 0)
-		return;
-	Clipoff(target);
-	Rect r, r1;
-	int   x, y, cx, cy, width, vertex_count, count_count;
-	Color color, pencolor, doxor;
-	Image img;
-	Drawing dw;
-	Painting sw;
-	Point p, p1;
-	int vi = 0;
-	while(!ps.IsEof()) {
-		int code;
-		ps / code;
-		switch(code) {
-		case DRAWING_BEGIN: 
-			Begin();
-			ps.Push();
-			break;
-		case DRAWING_OFFSET:
-			ps % p;
-			p1 = ps(p);
-			Offset(p1);
-			ps.Push();
-			ps.srcoff += p;
-			ps.trgoff += p1;
-			break;
-		case DRAWING_CLIP:
-			Clip(ps.GetRect());
-			ps.Push();
-			break;
-		case DRAWING_CLIPOFF:
-			ps % r;
-			r1 = ps(r);
-			Clipoff(r1);
-			ps.Push();
-			ps.srcoff += r.TopLeft();
-			ps.trgoff += r1.TopLeft();
-			break;
-		case DRAWING_EXCLUDECLIP:
-			ExcludeClip(ps.GetRect());
-			break;
-		case DRAWING_INTERSECTCLIP:
-			IntersectClip(ps.GetRect());
-			break;
-		case DRAWING_END:
-			End();
-			ps.Pop();
-			break;
-		case DRAWING_DRAWRECT:
-			ps % x % y % cx % cy % color;
-			DrawRect(ps(x, y, cx, cy), color);
-			break;
-		case DRAWING_DRAWIMAGE:
-			ps % x % y % cx % cy;
-			if(w.val.GetCount())
-				img = w.val[vi++];
-			else
-				ps % img;
-			ps % r % color;
-			DrawImageOp(ps.GetX(x), ps.GetY(y), ps.GetCx(cx), ps.GetCy(cy), img, r, color);
-			break;
-		case DRAWING_DRAWDATA:
-			{
-				String data, id;
-				ps % x % y % cx % cy % id;
-				if(w.val.GetCount())
-					data = w.val[vi++];
-				else
-					ps % data;
-				DrawData(ps(x, y, cx, cy), data, id);
-			}
-			break;
-		case DRAWING_DRAWDRAWING:
-			if(w.val.GetCount())
-				dw = w.val[vi++];
-			else
-				ps % dw;
-			DrawDrawing(ps.GetRect(), dw);
-			break;
-		case DRAWING_DRAWPAINTING:
-			if(w.val.GetCount())
-				sw = w.val[vi++];
-			else
-				ps % sw;
-			DrawPainting(ps.GetRect(), sw);
-			break;
-		case DRAWING_DRAWLINE:
-			ps % x % y % cx % cy % width % color;
-			DrawLine(ps(x, y), ps(cx, cy), width > 0 ? ps.GetW(width) : width, color);
-			break;
-		case DRAWING_DRAWELLIPSE:
-			r = ps.GetRect();
-			ps % color / width % pencolor;
-			DrawEllipse(r, color, width > 0 ? ps.GetW(width) : width, pencolor);
-			break;
-#ifndef PLATFORM_WINCE
-		case DRAWING_DRAWARC:
-			r = ps.GetRect();
-			ps % p % p1 % color % width;
-			DrawArc(r, ps(p), ps(p1), width > 0 ? ps.GetW(width) : width, color);
-			break;
-		case DRAWING_DRAWPOLYPOLYLINE:
-			{
-				int version;
-				ps / version;
-				ps % width % color % doxor;
-				ps % vertex_count % count_count;
-				Buffer<Point> vertices(vertex_count);
-				Buffer<int> counts(count_count);
-				StreamUnpackPoints(ps, vertices, vertex_count);
-				StreamUnpackInts(ps, counts, count_count);
-				if(!ps.Identity()) {
-					for(Point *p = vertices, *e = p + vertex_count; p < e; p++)
-						ps.Transform(*p);
-					if(width > 0)
-						ps.TransformW(width);
-				}
-				DrawPolyPolyline(vertices, vertex_count, counts, count_count, width, color, doxor);
-			}
-			break;
-		case DRAWING_DRAWPOLYPOLYPOLYGON:
-			{
-				Color outline;
-				uint64 pattern;
-				int subpolygon_count_count, disjunct_polygon_count_count;
-				int version = 2;
-				ps / version;
-				ps % color % width % outline % pattern % doxor;
-				ps % vertex_count % subpolygon_count_count % disjunct_polygon_count_count;
-				Buffer<Point> vertices(vertex_count);
-				Buffer<int> subpolygon_counts(subpolygon_count_count);
-				Buffer<int> disjunct_polygon_counts(disjunct_polygon_count_count);
-				StreamUnpackPoints(ps, vertices, vertex_count);
-				StreamUnpackInts(ps, subpolygon_counts, subpolygon_count_count);
-				StreamUnpackInts(ps, disjunct_polygon_counts, disjunct_polygon_count_count);
-				if(!ps.Identity()) {
-					for(Point *p = vertices, *e = p + vertex_count; p < e; p++)
-						ps.Transform(*p);
-					ps.TransformW(width);
-				}
-				DrawPolyPolyPolygon(vertices, vertex_count,
-				                    subpolygon_counts, subpolygon_count_count,
-				                    disjunct_polygon_counts, disjunct_polygon_count_count,
-				                    color, width, outline, pattern, doxor);
-			}
-			break;
-#endif
-		case DRAWING_DRAWTEXT:
-			{
-				int n, angle;
-				Font font;
-				Color ink;
-				byte cs;
-				ps % x % y % angle % font % ink / n % cs;
-				if(font.GetHeight() == 0) {
-					FontInfo fi = font.Info();
-					font.Height(fi.GetHeight() - fi.GetInternal());
-				}
-				bool unicode = cs == CHARSET_UNICODE;
-				WString text;
-				if(unicode) {
-					Buffer<wchar> txt(n);
-					ps.Stream::GetW(txt, n);
-					text = WString(txt, n);
-				}
-				else {
-					Buffer<char> txt(n);
-					ps.Stream::Get(txt, n);
-					text = ToUnicode(txt, n, cs);
-				}
-				LLOG("wsDrawText \"" << WString(text, n)
-				     << "\" at: (" << x << ", " << y << ", " << angle << ")");
-				bool dxb;
-				ps % dxb;
-				Buffer<int> dx(n);
-				int *wd = dx;
-				int nn = n;
-				angle %= 3600;
-				if(ps.Identity()) {
-					if(dxb) {
-						while(nn--)
-							ps / *wd++;
-						DrawText(x, y, angle, text, font, ink, dx);
-					}
-					else
-						DrawText(x, y, angle, text, font, ink);
-				}
-				else {
-					const wchar *wp = ~text;
-					double q = Length((Sizef)ps.target) / Length((Sizef)ps.source);
-					double px = 0;
-					while(nn--) {
-						int cx;
-						if(dxb)
-							ps / cx;
-						else
-							cx = font[*wp++];
-						double npx = q * cx + px;
-						*wd++ = (int)npx - (int)px;
-						px = npx;
-					}
-					int ht = (int)(font.GetHeight() * min(double(ps.target.cx) / ps.source.cx, double(ps.target.cy) / ps.source.cy));
-					font.Width((int)q * font.GetWidth()).Height(ht ? ht : 1);
-					DrawText(ps.GetX(x), ps.GetY(y), angle, text, font, ink, dx);
-				/*
-					FontInfo fi = font.Info();
-					const wchar *wp = ~text;
-					int odd = (angle / 900) & 1;
-					double ang = (double) (angle % 900) * M_2PI / 3600;
-					double sx = (double) ps.target.cx / ps.source.cx;
-					double sy = (double) ps.target.cy / ps.source.cy;
-					double ang2 = atan((odd ? sx / sy : sy / sx) * tan(ang));
-					DDUMP(odd);
-					DDUMP(cx);
-					DDUMP(sy);
-					DDUMP(sin(ang));
-					DDUMP(sin(ang2));
-					double q = (odd ? sx : sy) * sin(ang) / sin(ang2);
-					double error = 0;
-					while(nn--) {
-						int cx;
-						if(dxb) {
-							ps / cx;
-							DDUMP(cx);
-						}
-						else
-							cx = fi[*wp++];
-						double ncx = q * cx + error;
-						DDUMP(q * cx);
-						*wd++ = cx = (int) ncx;
-						error = ncx - cx;
-					}
-					int ht = (int)(fi.GetFontHeight() * (sx * sin(ang) * sin(ang2) + sy * cos(ang) * cos(ang2)));
-					font.Width(int(q * fi.GetAveWidth())).Height(ht ? ht : 1);
-					DrawText(ps.GetX(x), ps.GetY(y), int(ang2 * 3600 / M_2PI) + (angle / 900) * 900,
-					         text, font, ink, dx);
-				*/
-				}
-			}
-		}
-	}
-//	LOGEND();
-	End();
-#ifdef _DEBUG
-	ASSERT(GetCloffLevel() == cl);
-#endif
-}
-
-void Draw::DrawDrawing(int x, int y, int cx, int cy, const Drawing& w) {
-	DrawDrawing(RectC(x, y, cx, cy), w);
-}
-
-void  DrawingDraw::Create(int cx, int cy, bool dots_) {
-	Create(Size(cx, cy), dots_);
-}
-
-void  DrawingDraw::Create(Size sz, bool dots_) {
-	drawing.Create();
-	size = sz;
-	dots = dots_;
-	val.Clear();
-	LLOG("DrawingDraw::Create, sz = " << sz << ", dots = " << dots << " -> clip = " << GetClip());
-}
-
-DrawingDraw::DrawingDraw()
-{
-}
-
-DrawingDraw::DrawingDraw(Size sz, bool dots_) {
-	Create(sz, dots_);
-}
-
-DrawingDraw::DrawingDraw(int cx, int cy, bool dots_) {
-	Create(cx, cy, dots_);
-}
-
-Size Drawing::RatioSize(int cx, int cy) const {
-	return GetRatioSize(GetSize(), cx, cy);
-}
-
-void Drawing::Append(Drawing& dw)
-{
-	if(IsNull(size))
-		size = dw.size;
-	data << dw.data;
-	for(int i = 0; i < dw.val.GetCount(); i++)
-		val.Add(dw.val[i]);
-}
-
-Drawing::Drawing(const Value& src)
-{
-	if(IsNull(src))
-		size = Null;
-	else
-		*this = RichValue<Drawing>::Extract(src);
-}
-
-void Drawing::Serialize(Stream& s)
-{
-	if(val.GetCount())
-		size.cy |= 0x80000000;
-	s % size;
-	s % data;
-	if(size.cy & 0x80000000) {
-		size.cy &= ~0x80000000;
-		s % val;
-	}
-}
-
-END_UPP_NAMESPACE
+#include "Draw.h"
+
+NAMESPACE_UPP
+
+enum {
+	DRAWING_BEGIN               = 1,
+	DRAWING_OFFSET              = 2,
+	DRAWING_CLIP                = 3,
+	DRAWING_CLIPOFF             = 4,
+	DRAWING_EXCLUDECLIP         = 5,
+	DRAWING_INTERSECTCLIP       = 6,
+	DRAWING_END                 = 7,
+	DRAWING_DRAWRECT            = 8,
+	DRAWING_DRAWIMAGE           = 9,
+	DRAWING_DRAWMONOIMAGE       = 10,
+	DRAWING_DRAWDRAWING         = 11,
+	DRAWING_DRAWLINE            = 12,
+	DRAWING_DRAWELLIPSE         = 13,
+	DRAWING_DRAWTEXT            = 14,
+	DRAWING_DRAWARC             = 15,
+	DRAWING_DRAWPOLYPOLYLINE    = 16,
+	DRAWING_DRAWPOLYPOLYPOLYGON = 17,
+	DRAWING_DRAWDATA            = 18,
+	DRAWING_DRAWPAINTING        = 19,
+};
+
+
+#define LLOG(x)  // DLOG(x)
+
+#ifdef COMPILER_MSC
+#pragma warning(disable: 4700)
+#endif
+
+static void StreamUnpackPoints(Stream& stream, Point *out, int count)
+{
+	if(count == 0)
+		return;
+#ifdef CPU_LITTLE_ENDIAN
+	if(sizeof(Point) == 8) {
+		stream.Get(out, 8 * count);
+		return;
+	}
+#endif
+	Point *end = out + count;
+	byte *top = reinterpret_cast<byte *>(end) - count * 8;
+	stream.Get(top, count * 8);
+	for(; out < end; out++, top += 8) {
+		out -> x = (short)Peek32le(top + 0);
+		out -> y = (short)Peek32le(top + 4);
+	}
+}
+
+static void StreamPackPoints(Stream& stream, const Point *in, int count)
+{
+#ifdef CPU_LITTLE_ENDIAN
+	if(sizeof(Point) == 8) {
+		stream.Put(in, 8 * count);
+		return;
+	}
+#endif
+	enum { PART = 1024 };
+	byte part[PART * 8];
+	while(count > 0)
+	{
+		int part_count = min<int>(count, PART);
+		for(byte *pp = part, *pe = pp + 8 * part_count; pp < pe; pp += 8, in++) {
+			Poke32le(pp + 0, in -> x);
+			Poke32le(pp + 4, in -> y);
+		}
+		stream.Put(part, part_count * 4);
+		count -= part_count;
+	}
+}
+
+static void StreamUnpackInts(Stream& stream, int *out, int count)
+{
+#ifdef CPU_LITTLE_ENDIAN
+	if(sizeof(int) == 4) {
+		stream.Get(out, count * 4);
+		return;
+	}
+#endif
+	while(count--)
+		*out++ = stream.Get32le();
+}
+
+static void StreamPackInts(Stream& stream, const int *in, int count)
+{
+#ifdef CPU_LITTLE_ENDIAN
+	if(sizeof(int) == 4) {
+		stream.Put(in, count * 4);
+		return;
+	}
+#endif
+	while(count--)
+		stream.Put32le(*in++);
+}
+
+// ------------------------------
+
+Stream& DrawingDraw::DrawingOp(int code)
+{
+	drawing / code;
+	return drawing;
+}
+
+dword DrawingDraw::GetInfo() const
+{
+	return dots ? DOTS : 0;
+}
+
+Size DrawingDraw::GetPageSize() const
+{
+	return size;
+}
+
+Rect DrawingDraw::GetPaintRect() const
+{
+	return Rect(size);
+}
+
+void DrawingDraw::BeginOp()
+{
+	DrawingOp(DRAWING_BEGIN);
+}
+
+void DrawingDraw::OffsetOp(Point p)
+{
+	DrawingOp(DRAWING_OFFSET) % p;
+}
+
+bool DrawingDraw::ClipOp(const Rect& r)
+{
+	DrawingOp(DRAWING_CLIP) % const_cast<Rect&>(r);
+	return true;
+}
+
+bool DrawingDraw::ClipoffOp(const Rect& r)
+{
+	DrawingOp(DRAWING_CLIPOFF) % const_cast<Rect&>(r);
+	return true;
+}
+
+void DrawingDraw::EndOp()
+{
+	DrawingOp(DRAWING_END);
+}
+
+bool DrawingDraw::ExcludeClipOp(const Rect& r)
+{
+	DrawingOp(DRAWING_EXCLUDECLIP) % const_cast<Rect&>(r);
+	return true;
+}
+
+bool DrawingDraw::IntersectClipOp(const Rect& r)
+{
+	DrawingOp(DRAWING_INTERSECTCLIP) % const_cast<Rect&>(r);
+	return true;
+}
+
+bool DrawingDraw::IsPaintingOp(const Rect& r) const
+{
+	return true;
+}
+
+void DrawingDraw::DrawRectOp(int x, int y, int cx, int cy, Color color)
+{
+	if(!IsNull(color))
+		DrawingOp(DRAWING_DRAWRECT) % x % y % cx % cy % color;
+}
+
+void DrawingDraw::DrawImageOp(int x, int y, int cx, int cy, const Image& img, const Rect& src, Color color)
+{
+	Rect s = src;
+	DrawingOp(DRAWING_DRAWIMAGE) % x % y % cx % cy % s % color;
+	val.Add(img);
+}
+
+void DrawingDraw::DrawDataOp(int x, int y, int cx, int cy, const String& data, const char *id)
+{
+	String h = id;
+	DrawingOp(DRAWING_DRAWDATA) % x % y % cx % cy % h;
+	val.Add(data);
+}
+
+void DrawingDraw::DrawDrawingOp(const Rect& target, const Drawing& w)
+{
+	DrawingOp(DRAWING_DRAWDRAWING) % const_cast<Rect&>(target);
+	val.Add(w);
+}
+
+void DrawingDraw::DrawPaintingOp(const Rect& target, const Painting& w)
+{
+	DrawingOp(DRAWING_DRAWPAINTING) % const_cast<Rect&>(target);
+	val.Add(w);
+}
+
+void DrawingDraw::DrawLineOp(int x1, int y1, int x2, int y2, int width, Color color)
+{
+	DrawingOp(DRAWING_DRAWLINE) % x1 % y1 % x2 % y2 % width % color;
+}
+
+void DrawingDraw::DrawPolyPolylineOp(const Point *vertices, int vertex_count,
+	                                 const int *counts, int count_count,
+	                                 int width, Color color, Color doxor)
+{
+	ASSERT(count_count > 0 && vertex_count > 0);
+	if(vertex_count < 2 || IsNull(color))
+		return;
+	DrawingOp(DRAWING_DRAWPOLYPOLYLINE);
+	int version = 2;
+	drawing / version;
+	drawing % width % color % doxor;
+	drawing % vertex_count % count_count;
+	StreamPackPoints(drawing, vertices, vertex_count);
+	StreamPackInts(drawing, counts, count_count);
+}
+
+void DrawingDraw::DrawPolyPolyPolygonOp(const Point *vertices, int vertex_count,
+	                   const int *subpolygon_counts, int subpolygon_count_count,
+	                   const int *disjunct_polygon_counts, int disjunct_polygon_count_count,
+	                   Color color, int width, Color outline, uint64 pattern, Color doxor)
+{
+	if(vertex_count == 0)
+		return;
+	DrawingOp(DRAWING_DRAWPOLYPOLYPOLYGON);
+	int version = 2;
+	drawing / version;
+	drawing % color % width % outline % pattern % doxor;
+	drawing % vertex_count % subpolygon_count_count % disjunct_polygon_count_count;
+	StreamPackPoints(drawing, vertices, vertex_count);
+	StreamPackInts(drawing, subpolygon_counts, subpolygon_count_count);
+	StreamPackInts(drawing, disjunct_polygon_counts, disjunct_polygon_count_count);
+}
+
+void DrawingDraw::DrawEllipseOp(const Rect& r, Color color, int pen, Color pencolor)
+{
+	DrawingOp(DRAWING_DRAWELLIPSE) % const_cast<Rect&>(r) % color / pen % pencolor;
+}
+
+void DrawingDraw::DrawArcOp(const Rect& rc, Point start, Point end, int width, Color color)
+{
+	DrawingOp(DRAWING_DRAWARC) % const_cast<Rect&>(rc) % start % end % color % width;
+}
+
+void DrawingDraw::DrawTextOp(int x, int y, int angle, const wchar *text, Font font, Color ink,
+                             int n, const int *dx) {
+	if(IsNull(ink)) return;
+	if(n < 0)
+		n = wstrlen((const wchar *)text);
+	if(n == 0)
+		return;
+	Stream& s = DrawingOp(DRAWING_DRAWTEXT);
+	byte cs = CHARSET_UNICODE;
+	s % x % y % angle % font % ink / n % cs;
+	s.PutW((wchar *)text, n);
+	bool dxb = dx;
+	s % dxb;
+	if(dx) {
+		int *w = const_cast<int *>(dx);
+		while(n--)
+			s / *w++;
+	}
+}
+
+Drawing DrawingDraw::GetResult()
+{
+	Drawing out;
+	out.size = size;
+	LLOG("GetResult size: " << size);
+	out.data = drawing.GetResult();
+	out.val = val;
+	return out;
+}
+
+// ------------------------------
+
+struct Draw::DrawingPos : StringStream {
+	Size    source;
+	Size    target;
+	Point   srcoff;
+	Point   trgoff;
+
+	Vector<Point> stk;
+
+	bool  Identity() const                               { return source == target; }
+
+	int   GetX(int x) const;
+	int   GetY(int y) const;
+	int   GetCx(int cx) const;
+	int   GetCy(int cy) const;
+	int   GetW(int w) const;
+	Point Get(int x, int y) const;
+	Point Get(Point p) const;
+	Rect  Get(const Rect& r) const;
+	Rect  Get(int x, int y, int cx, int cy) const;
+
+	Point operator()(int x, int y) const                 { return Get(x, y); }
+	Point operator()(Point p) const                      { return Get(p); }
+	Rect  operator()(const Rect& r) const                { return Get(r); }
+	Rect  operator()(int x, int y, int cx, int cy) const { return Get(x, y, cx, cy); }
+
+	void TransformX(int& x) const                        { x = GetX(x); }
+	void TransformY(int& y) const                        { y = GetY(y); }
+	void TransformW(int& w) const                        { w = GetW(w); }
+	void Transform(int& x, int& y) const                 { TransformX(x); TransformY(y); }
+	void Transform(Point& p) const                       { p = Get(p); }
+	void Transform(Rect& r) const                        { r = Get(r); }
+	
+	Rect  GetRect();
+	
+	void  Push();
+	void  Pop();
+	
+	DrawingPos(const String& src) : StringStream(src) {}
+};
+
+void Draw::DrawingPos::Push()
+{
+	stk.Add(srcoff);
+	stk.Add(trgoff);
+}
+
+void Draw::DrawingPos::Pop()
+{
+	trgoff = stk.Pop();
+	srcoff = stk.Pop();
+}
+
+Rect Draw::DrawingPos::GetRect()
+{
+	Rect r;
+	*this % r;
+	return Get(r);
+}
+
+int   Draw::DrawingPos::GetX(int x) const {
+	return iscale(x + srcoff.x, target.cx, source.cx) - trgoff.x;
+}
+
+int   Draw::DrawingPos::GetY(int y) const {
+	return iscale(y + srcoff.y, target.cy, source.cy) - trgoff.y;
+}
+
+int   Draw::DrawingPos::GetCx(int cx) const {
+	return iscale(cx, target.cx, source.cx);
+}
+
+int   Draw::DrawingPos::GetCy(int cy) const {
+	return iscale(cy, target.cy, source.cy);
+}
+
+int   Draw::DrawingPos::GetW(int w) const {
+	return iscale(w, target.cx + target.cy, source.cx + source.cy);
+}
+
+Point Draw::DrawingPos::Get(int x, int y) const {
+	return Point(GetX(x), GetY(y));
+}
+
+Point Draw::DrawingPos::Get(Point p) const {
+	return Get(p.x, p.y);
+}
+
+Rect  Draw::DrawingPos::Get(const Rect& r) const {
+	return Rect(GetX(r.left), GetY(r.top), GetX(r.right), GetY(r.bottom));
+}
+
+Rect  Draw::DrawingPos::Get(int x, int y, int cx, int cy) const {
+	return Get(RectC(x, y, cx, cy));
+}
+
+void Draw::DrawDrawingOp(const Rect& target, const Drawing& w) {
+#ifdef _DEBUG
+	int cl = GetCloffLevel();
+#endif
+	DrawingPos ps(w.data);
+	ps.srcoff = ps.trgoff = Point(0, 0);
+	ps.target = target.Size();
+	ps.source = w.size;
+	LLOG("DrawDrawingOp size: " << w.size);
+	if(ps.target.cx == 0 || ps.target.cy == 0 || ps.source.cx == 0 || ps.source.cy == 0)
+		return;
+	Clipoff(target);
+	Rect r, r1;
+	int   x, y, cx, cy, width, vertex_count, count_count;
+	Color color, pencolor, doxor;
+	Image img;
+	Drawing dw;
+	Painting sw;
+	Point p, p1;
+	int vi = 0;
+	while(!ps.IsEof()) {
+		int code;
+		ps / code;
+		switch(code) {
+		case DRAWING_BEGIN: 
+			Begin();
+			ps.Push();
+			break;
+		case DRAWING_OFFSET:
+			ps % p;
+			p1 = ps(p);
+			Offset(p1);
+			ps.Push();
+			ps.srcoff += p;
+			ps.trgoff += p1;
+			break;
+		case DRAWING_CLIP:
+			Clip(ps.GetRect());
+			ps.Push();
+			break;
+		case DRAWING_CLIPOFF:
+			ps % r;
+			r1 = ps(r);
+			Clipoff(r1);
+			ps.Push();
+			ps.srcoff += r.TopLeft();
+			ps.trgoff += r1.TopLeft();
+			break;
+		case DRAWING_EXCLUDECLIP:
+			ExcludeClip(ps.GetRect());
+			break;
+		case DRAWING_INTERSECTCLIP:
+			IntersectClip(ps.GetRect());
+			break;
+		case DRAWING_END:
+			End();
+			ps.Pop();
+			break;
+		case DRAWING_DRAWRECT:
+			ps % x % y % cx % cy % color;
+			DrawRect(ps(x, y, cx, cy), color);
+			break;
+		case DRAWING_DRAWIMAGE:
+			ps % x % y % cx % cy;
+			if(w.val.GetCount())
+				img = w.val[vi++];
+			else
+				ps % img;
+			ps % r % color;
+			DrawImageOp(ps.GetX(x), ps.GetY(y), ps.GetCx(cx), ps.GetCy(cy), img, r, color);
+			break;
+		case DRAWING_DRAWDATA:
+			{
+				String data, id;
+				ps % x % y % cx % cy % id;
+				if(w.val.GetCount())
+					data = w.val[vi++];
+				else
+					ps % data;
+				DrawData(ps(x, y, cx, cy), data, id);
+			}
+			break;
+		case DRAWING_DRAWDRAWING:
+			if(w.val.GetCount())
+				dw = w.val[vi++];
+			else
+				ps % dw;
+			DrawDrawing(ps.GetRect(), dw);
+			break;
+		case DRAWING_DRAWPAINTING:
+			if(w.val.GetCount())
+				sw = w.val[vi++];
+			else
+				ps % sw;
+			DrawPainting(ps.GetRect(), sw);
+			break;
+		case DRAWING_DRAWLINE:
+			ps % x % y % cx % cy % width % color;
+			DrawLine(ps(x, y), ps(cx, cy), width > 0 ? ps.GetW(width) : width, color);
+			break;
+		case DRAWING_DRAWELLIPSE:
+			r = ps.GetRect();
+			ps % color / width % pencolor;
+			DrawEllipse(r, color, width > 0 ? ps.GetW(width) : width, pencolor);
+			break;
+#ifndef PLATFORM_WINCE
+		case DRAWING_DRAWARC:
+			r = ps.GetRect();
+			ps % p % p1 % color % width;
+			DrawArc(r, ps(p), ps(p1), width > 0 ? ps.GetW(width) : width, color);
+			break;
+		case DRAWING_DRAWPOLYPOLYLINE:
+			{
+				int version;
+				ps / version;
+				ps % width % color % doxor;
+				ps % vertex_count % count_count;
+				Buffer<Point> vertices(vertex_count);
+				Buffer<int> counts(count_count);
+				StreamUnpackPoints(ps, vertices, vertex_count);
+				StreamUnpackInts(ps, counts, count_count);
+				if(!ps.Identity()) {
+					for(Point *p = vertices, *e = p + vertex_count; p < e; p++)
+						ps.Transform(*p);
+					if(width > 0)
+						ps.TransformW(width);
+				}
+				DrawPolyPolyline(vertices, vertex_count, counts, count_count, width, color, doxor);
+			}
+			break;
+		case DRAWING_DRAWPOLYPOLYPOLYGON:
+			{
+				Color outline;
+				uint64 pattern;
+				int subpolygon_count_count, disjunct_polygon_count_count;
+				int version = 2;
+				ps / version;
+				ps % color % width % outline % pattern % doxor;
+				ps % vertex_count % subpolygon_count_count % disjunct_polygon_count_count;
+				Buffer<Point> vertices(vertex_count);
+				Buffer<int> subpolygon_counts(subpolygon_count_count);
+				Buffer<int> disjunct_polygon_counts(disjunct_polygon_count_count);
+				StreamUnpackPoints(ps, vertices, vertex_count);
+				StreamUnpackInts(ps, subpolygon_counts, subpolygon_count_count);
+				StreamUnpackInts(ps, disjunct_polygon_counts, disjunct_polygon_count_count);
+				if(!ps.Identity()) {
+					for(Point *p = vertices, *e = p + vertex_count; p < e; p++)
+						ps.Transform(*p);
+					ps.TransformW(width);
+				}
+				DrawPolyPolyPolygon(vertices, vertex_count,
+				                    subpolygon_counts, subpolygon_count_count,
+				                    disjunct_polygon_counts, disjunct_polygon_count_count,
+				                    color, width, outline, pattern, doxor);
+			}
+			break;
+#endif
+		case DRAWING_DRAWTEXT:
+			{
+				int n, angle;
+				Font font;
+				Color ink;
+				byte cs;
+				ps % x % y % angle % font % ink / n % cs;
+				if(font.GetHeight() == 0) {
+					FontInfo fi = font.Info();
+					font.Height(fi.GetHeight() - fi.GetInternal());
+				}
+				bool unicode = cs == CHARSET_UNICODE;
+				WString text;
+				if(unicode) {
+					Buffer<wchar> txt(n);
+					ps.Stream::GetW(txt, n);
+					text = WString(txt, n);
+				}
+				else {
+					Buffer<char> txt(n);
+					ps.Stream::Get(txt, n);
+					text = ToUnicode(txt, n, cs);
+				}
+				LLOG("wsDrawText \"" << WString(text, n)
+				     << "\" at: (" << x << ", " << y << ", " << angle << ")");
+				bool dxb;
+				ps % dxb;
+				Buffer<int> dx(n);
+				int *wd = dx;
+				int nn = n;
+				angle %= 3600;
+				if(ps.Identity()) {
+					if(dxb) {
+						while(nn--)
+							ps / *wd++;
+						DrawText(x, y, angle, text, font, ink, dx);
+					}
+					else
+						DrawText(x, y, angle, text, font, ink);
+				}
+				else {
+					const wchar *wp = ~text;
+					double q = Length((Sizef)ps.target) / Length((Sizef)ps.source);
+					double px = 0;
+					while(nn--) {
+						int cx;
+						if(dxb)
+							ps / cx;
+						else
+							cx = font[*wp++];
+						double npx = q * cx + px;
+						*wd++ = (int)npx - (int)px;
+						px = npx;
+					}
+					int ht = (int)(font.GetHeight() * min(double(ps.target.cx) / ps.source.cx, double(ps.target.cy) / ps.source.cy));
+					font.Width((int)q * font.GetWidth()).Height(ht ? ht : 1);
+					DrawText(ps.GetX(x), ps.GetY(y), angle, text, font, ink, dx);
+				/*
+					FontInfo fi = font.Info();
+					const wchar *wp = ~text;
+					int odd = (angle / 900) & 1;
+					double ang = (double) (angle % 900) * M_2PI / 3600;
+					double sx = (double) ps.target.cx / ps.source.cx;
+					double sy = (double) ps.target.cy / ps.source.cy;
+					double ang2 = atan((odd ? sx / sy : sy / sx) * tan(ang));
+					DDUMP(odd);
+					DDUMP(cx);
+					DDUMP(sy);
+					DDUMP(sin(ang));
+					DDUMP(sin(ang2));
+					double q = (odd ? sx : sy) * sin(ang) / sin(ang2);
+					double error = 0;
+					while(nn--) {
+						int cx;
+						if(dxb) {
+							ps / cx;
+							DDUMP(cx);
+						}
+						else
+							cx = fi[*wp++];
+						double ncx = q * cx + error;
+						DDUMP(q * cx);
+						*wd++ = cx = (int) ncx;
+						error = ncx - cx;
+					}
+					int ht = (int)(fi.GetFontHeight() * (sx * sin(ang) * sin(ang2) + sy * cos(ang) * cos(ang2)));
+					font.Width(int(q * fi.GetAveWidth())).Height(ht ? ht : 1);
+					DrawText(ps.GetX(x), ps.GetY(y), int(ang2 * 3600 / M_2PI) + (angle / 900) * 900,
+					         text, font, ink, dx);
+				*/
+				}
+			}
+		}
+	}
+//	LOGEND();
+	End();
+#ifdef _DEBUG
+	ASSERT(GetCloffLevel() == cl);
+#endif
+}
+
+void Draw::DrawDrawing(int x, int y, int cx, int cy, const Drawing& w) {
+	DrawDrawing(RectC(x, y, cx, cy), w);
+}
+
+void  DrawingDraw::Create(int cx, int cy, bool dots_) {
+	Create(Size(cx, cy), dots_);
+}
+
+void  DrawingDraw::Create(Size sz, bool dots_) {
+	drawing.Create();
+	size = sz;
+	dots = dots_;
+	val.Clear();
+	LLOG("DrawingDraw::Create, sz = " << sz << ", dots = " << dots << " -> clip = " << GetClip());
+}
+
+DrawingDraw::DrawingDraw()
+{
+}
+
+DrawingDraw::DrawingDraw(Size sz, bool dots_) {
+	Create(sz, dots_);
+}
+
+DrawingDraw::DrawingDraw(int cx, int cy, bool dots_) {
+	Create(cx, cy, dots_);
+}
+
+Size Drawing::RatioSize(int cx, int cy) const {
+	return GetRatioSize(GetSize(), cx, cy);
+}
+
+void Drawing::Append(Drawing& dw)
+{
+	if(IsNull(size))
+		size = dw.size;
+	data << dw.data;
+	for(int i = 0; i < dw.val.GetCount(); i++)
+		val.Add(dw.val[i]);
+}
+
+Drawing::Drawing(const Value& src)
+{
+	if(IsNull(src))
+		size = Null;
+	else
+		*this = RichValue<Drawing>::Extract(src);
+}
+
+void Drawing::Serialize(Stream& s)
+{
+	if(val.GetCount())
+		size.cy |= 0x80000000;
+	s % size;
+	s % data;
+	if(size.cy & 0x80000000) {
+		size.cy &= ~0x80000000;
+		s % val;
+	}
+}
+
+END_UPP_NAMESPACE
diff --git a/uppsrc/Draw/Font.cpp b/uppsrc/Draw/Font.cpp
index e2a889cca..5e5610271 100644
--- a/uppsrc/Draw/Font.cpp
+++ b/uppsrc/Draw/Font.cpp
@@ -25,7 +25,7 @@ Size Font::StdFontSize;
 Font Font::AStdFont;
 
 INITBLOCK {
-	RichValue<Font>::Register();
+	Value::Register<Font>("Font");
 }
 
 const Vector<FaceInfo>& Font::List()
@@ -292,6 +292,7 @@ String Font::GetFaceNameStd() const
 	return GetFaceName();
 }
 
+#ifdef SVO_VALUE
 void Font::Jsonize(JsonIO& jio)
 {
 	String n, tf;
@@ -330,6 +331,7 @@ void Font::Xmlize(XmlIO& xio)
 		ParseTextFlags(tf);
 	}
 }
+#endif
 
 template<>
 String AsString(const Font& f) {
diff --git a/uppsrc/Draw/Image.cpp b/uppsrc/Draw/Image.cpp
index 8850e7be3..3a31a9977 100644
--- a/uppsrc/Draw/Image.cpp
+++ b/uppsrc/Draw/Image.cpp
@@ -1,735 +1,735 @@
-#include "Draw.h"
-
-NAMESPACE_UPP
-
-#define LTIMING(x) // RTIMING(x)
-
-int ImageBuffer::ScanKind() const
-{
-	bool a255 = false;
-	bool a0 = false;
-	const RGBA *s = pixels;
-	const RGBA *e = s + GetLength();
-	while(s < e) {
-		if(s->a == 0)
-			a0 = true;
-		else
-		if(s->a == 255)
-			a255 = true;
-		else
-			return IMAGE_ALPHA;
-		s++;
-	}
-	return a255 ? a0 ? IMAGE_MASK : IMAGE_OPAQUE : IMAGE_EMPTY;
-}
-
-void ImageBuffer::SetHotSpots(const Image& src)
-{
-	SetHotSpot(src.GetHotSpot());
-	Set2ndSpot(src.Get2ndSpot());
-}
-
-void ImageBuffer::Create(int cx, int cy)
-{
-	ASSERT(cx >= 0 && cy >= 0);
-	size.cx = cx;
-	size.cy = cy;
-	pixels.Alloc(GetLength());
-#ifdef _DEBUG
-	RGBA *s = pixels;
-	RGBA *e = pixels + GetLength();
-	byte  a = 0;
-	while(s < e) {
-		s->a = a;
-		a = ~a;
-		s->r = 255;
-		s->g = s->b = 0;
-		s++;
-	}
-#endif
-	kind = IMAGE_UNKNOWN;
-	spot2 = hotspot = Point(0, 0);
-	dots = Size(0, 0);
-}
-
-void ImageBuffer::DeepCopy(const ImageBuffer& img)
-{
-	Create(img.GetSize());
-	SetHotSpot(img.GetHotSpot());
-	Set2ndSpot(img.Get2ndSpot());
-	SetDots(img.GetDots());
-	memcpy(pixels, img.pixels, GetLength() * sizeof(RGBA));
-}
-
-void ImageBuffer::Set(Image& img)
-{
-	if(img.data)
-		if(img.data->refcount == 1) {
-			size = img.GetSize();
-			kind = IMAGE_UNKNOWN;
-			hotspot = img.GetHotSpot();
-			spot2 = img.Get2ndSpot();
-			dots = img.GetDots();
-			pixels = img.data->buffer.pixels;
-			img.Clear();
-		}
-		else {
-			DeepCopy(img.data->buffer);
-			kind = IMAGE_UNKNOWN;
-			img.Clear();
-		}
-	else
-		Create(0, 0);
-}
-
-
-void ImageBuffer::operator=(Image& img)
-{
-	Clear();
-	Set(img);
-}
-
-void ImageBuffer::operator=(ImageBuffer& img)
-{
-	Clear();
-	Image m = img;
-	Set(m);
-}
-
-ImageBuffer::ImageBuffer(Image& img)
-{
-	Set(img);
-}
-
-ImageBuffer::ImageBuffer(ImageBuffer& b)
-{
-	kind = b.kind;
-	size = b.size;
-	dots = b.dots;
-	pixels = b.pixels;
-	hotspot = b.hotspot;
-	spot2 = b.spot2;
-}
-
-void ImageBuffer::SetDPI(Size dpi) 
-{
-	dots.cx = int(600.*size.cx/dpi.cx);
-	dots.cy = int(600.*size.cy/dpi.cy);
-}
-
-Size ImageBuffer::GetDPI() 
-{
-	return Size(dots.cx ? int(600.*size.cx/dots.cx) : 0, dots.cy ? int(600.*size.cy/dots.cy) : 0);
-}
-
-void  (Image::Data::*Image::Data::sSysInit)();
-void  (Image::Data::*Image::Data::sSysRelease)();
-int   (Image::Data::*Image::Data::sGetResCount)() const;
-void  (Image::Data::*Image::Data::sPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c);
-
-void Image::Data::InitSystemImage(
-	void  (Image::Data::*fSysInit)(),
-	void  (Image::Data::*fSysRelease)(),
-	int   (Image::Data::*fGetResCount)() const,
-	void  (Image::Data::*fPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c)
-)
-{
-	Image::Data::sSysInit = fSysInit;
-	Image::Data::sSysRelease = fSysRelease;
-	Image::Data::sGetResCount = fGetResCount;
-	Image::Data::sPaint = fPaint;
-}
-
-void Image::Data::SysInit()
-{
-	if(sSysInit)
-		(this->*sSysInit)();
-}
-
-void Image::Data::SysRelease()
-{
-	if(sSysRelease)
-		(this->*sSysRelease)();
-}
-
-int Image::Data::GetResCount() const
-{
-	if(sGetResCount)
-		return (this->*sGetResCount)();
-	return 0;
-}
-
-void Image::Data::Paint(SystemDraw& w, int x, int y, const Rect& src, Color c)
-{
-	if(sPaint)
-		(this->*sPaint)(w, x, y, src, c);
-}
-
-void Image::Set(ImageBuffer& b)
-{
-	if(b.GetWidth() == 0 || b.GetHeight() == 0)
-		data = NULL;
-	else
-		data = new Data(b);
-}
-
-void Image::Clear()
-{
-	if(data)
-		data->Release();
-	data = NULL;
-}
-
-Image& Image::operator=(ImageBuffer& img)
-{
-	if(data)
-		data->Release();
-	Set(img);
-	return *this;
-}
-
-Image& Image::operator=(const Image& img)
-{
-	Data *d = data;
-	data = img.data;
-	if(data)
-		data->Retain();
-	if(d)
-		d->Release();
-	return *this;
-}
-
-const RGBA* Image::operator~() const
-{
-	return data ? ~data->buffer : NULL;
-}
-
-Image::operator const RGBA*() const
-{
-	return data ? ~data->buffer : NULL;
-}
-
-const RGBA* Image::operator[](int i) const
-{
-	ASSERT(data);
-	return data->buffer[i];
-}
-
-Size Image::GetSize() const
-{
-	return data ? data->buffer.GetSize() : Size(0, 0);
-}
-
-int Image::GetLength() const
-{
-	return data ? data->buffer.GetLength() : 0;
-}
-
-Point Image::GetHotSpot() const
-{
-	return data ? data->buffer.GetHotSpot() : Point(0, 0);
-}
-
-Point Image::Get2ndSpot() const
-{
-	return data ? data->buffer.Get2ndSpot() : Point(0, 0);
-}
-
-Size Image::GetDots() const
-{
-	return data ? data->buffer.GetDots() : Size(0, 0);
-}
-
-Size Image::GetDPI() 
-{
-	Size size = GetSize();
-	Size dots = GetDots();
-	return data ?  Size(int(600.*size.cx/dots.cx), int(600.*size.cy/dots.cy)): Size(0, 0);
-}
-
-int Image::GetKindNoScan() const
-{
-	return data ? data->buffer.GetKind() : IMAGE_EMPTY;
-}
-
-int Image::Data::GetKind()
-{
-	int k = buffer.GetKind();
-	if(k != IMAGE_UNKNOWN)
-		return k;
-	k = buffer.ScanKind();
-	buffer.SetKind(k);
-	return k;
-}
-
-int Image::GetKind() const
-{
-	return data ? data->GetKind() : IMAGE_EMPTY;
-}
-
-void Image::PaintImage(SystemDraw& w, int x, int y, const Rect& src, Color c) const
-{
-	if(data)
-		data->Paint(w, x, y, src, c);
-}
-
-void Image::Serialize(Stream& s)
-{
-	int version = 0;
-	s / version;
-	Size sz = GetSize();
-	Point p = GetHotSpot();
-	Size dots = GetDots();
-	s % sz % p % dots;
-	int len = sz.cx * sz.cy;
-	if(s.IsLoading())
-		if(len) {
-			ImageBuffer b(sz);
-			if(!s.GetAll(~b, len * sizeof(RGBA)))
-				s.SetError();
-			b.SetDots(dots);
-			b.SetHotSpot(p);
-			*this = b;
-		}
-		else
-			Clear();
-	else
-		s.Put(~*this, len * sizeof(RGBA));
-}
-
-INITBLOCK {
-	RichValue<Image>::Register();
-}
-
-bool Image::operator==(const Image& img) const
-{
-	if(GetLength() != img.GetLength())
-		return false;
-	return memcmp(~*this, ~img, GetLength() * sizeof(RGBA)) == 0;
-}
-
-bool Image::operator!=(const Image& img) const
-{
-	return !operator==(img);
-}
-
-dword Image::GetHashValue() const
-{
-	return memhash(~*this, GetLength() * sizeof(RGBA));
-}
-
-Image::Image(const Image& img)
-{
-	data = img.data;
-	if(data)
-		data->Retain();
-}
-
-Image::Image(Image (*fn)())
-{
-	data = NULL;
-	*this = (*fn)();
-}
-
-Image::Image(const Value& src)
-{
-	data = NULL;
-	if(!IsNull(src))
-		*this = RawValue<Image>::Extract(src);
-}
-
-Image::Image(ImageBuffer& b)
-{
-	Set(b);
-}
-
-Image::~Image()
-{
-	if(data)
-		data->Release();
-}
-
-Image::Image(const Init& init)
-{
-	ASSERT(init.info[0] >= 1);
-	Size sz;
-	sz.cx = Peek32le(init.info + 1);
-	sz.cy = Peek32le(init.info + 5);
-	ImageBuffer b(sz);
-	int i = 0;
-	while(i < init.scan_count) {
-		UnpackRLE(b[i], (const byte *)init.scans[i], sz.cx);
-		i++;
-	}
-	while(i < sz.cy)
-		memset(b[i++], 0, sizeof(RGBA) * sz.cx);
-	b.SetHotSpot(Point(Peek32le(init.info + 9), Peek32le(init.info + 13)));
-	Set(b);
-}
-
-String Image::ToString() const
-{
-	return String("Image ").Cat() << GetSize();
-}
-
-Link<Image::Data>     Image::Data::ResData[1];
-int                   Image::Data::ResCount;
-
-Image::Data::Data(ImageBuffer& b)
-:	buffer(b)
-{
-	paintcount = 0;
-	paintonly = false;
-	refcount = 1;
-	INTERLOCKED {
-		static int64 gserial;
-		serial = ++gserial;
-	}
-	SysInit();
-}
-
-Image::Data::~Data()
-{
-	DrawLock __;
-	SysRelease();
-	Unlink();
-}
-
-void Image::Data::PaintOnlyShrink()
-{
-	if(paintonly) {
-		LTIMING("PaintOnlyShrink");
-		DrawLock __;
-		DropPixels___(buffer);
-		ResCount -= GetResCount();
-		Unlink();
-	}
-}
-
-static void sMultiply(ImageBuffer& b, int (*op)(RGBA *t, const RGBA *s, int len))
-{
-	if(b.GetKind() != IMAGE_OPAQUE && b.GetKind() != IMAGE_EMPTY)
-		(*op)(~b, ~b, b.GetLength());
-}
-
-void Premultiply(ImageBuffer& b)
-{
-	sMultiply(b, Premultiply);
-}
-
-void Unmultiply(ImageBuffer& b)
-{
-	sMultiply(b, Unmultiply);
-}
-
-static Image sMultiply(const Image& img, int (*op)(RGBA *t, const RGBA *s, int len))
-{
-	int k = img.GetKind();
-	if(k == IMAGE_OPAQUE || k == IMAGE_EMPTY)
-		return img;
-	ImageBuffer ib(img.GetSize());
-	ib.SetHotSpot(img.GetHotSpot());
-	ib.Set2ndSpot(img.Get2ndSpot());
-	ib.SetKind(Premultiply(~ib, ~img, ib.GetLength()));
-	return ib;
-}
-
-Image Premultiply(const Image& img)
-{
-	return sMultiply(img, Premultiply);
-}
-
-Image Unmultiply(const Image& img)
-{
-	return sMultiply(img, Unmultiply);
-}
-
-void SetPaintOnly___(Image& m)
-{
-	if(m.data && m.data->refcount == 1)
-		m.data->paintonly = true;
-}
-
-void Iml::Init(int n)
-{
-	for(int i = 0; i < n; i++)
-		map.Add(name[i]);
-}
-
-void Iml::Reset()
-{
-	int n = map.GetCount();
-	map.Clear();
-	Init(n);
-}
-
-void Iml::Set(int i, const Image& img)
-{
-	map[i].image = img;
-	map[i].loaded = true;
-}
-
-Image Iml::Get(int i)
-{
-	IImage& m = map[i];
-	if(!m.loaded) {
-		DrawLock __;
-		if(data.GetCount()) {
-			int ii = 0;
-			for(;;) {
-				const Data& d = data[ii];
-				if(i < d.count) {
-					static const char   *cached_data;
-					static Vector<Image> cached;
-					if(cached_data != d.data) {
-						cached_data = d.data;
-						cached = UnpackImlData(d.data, d.len);
-						if(premultiply)
-							for(int i = 0; i < cached.GetCount(); i++)
-								cached[i] = Premultiply(cached[i]);
-					}
-					m.image = cached[i];
-					break;
-				}
-				i -= d.count;
-				ii++;
-			}
-		}
-		else
-			m.image = Premultiply(Image(img_init[i]));
-		m.loaded = true;
-	}
-	return m.image;
-}
-
-#ifdef _DEBUG
-int  Iml::GetBinSize() const
-{
-	int size = 0;
-	for(int i = 0; i < map.GetCount(); i++) {
-		const Image::Init& init = img_init[i];
-		size += (int)strlen(name[i]) + 1 + 24;
-		for(int q = 0; q < init.scan_count; q++)
-			size += (int)strlen(init.scans[q]);
-	}
-	return size;
-}
-#endif
-
-Iml::Iml(const Image::Init *img_init, const char **name, int n)
-:	img_init(img_init),
-	name(name)
-{
-#ifdef flagCHECKINIT
-	RLOG("Constructing iml " << *name);
-#endif
-	premultiply = true;
-	Init(n);
-}
-
-void Iml::AddData(const byte *_data, int len, int count)
-{
-	Data& d = data.Add();
-	d.data = (const char *)_data;
-	d.len = len;
-	d.count = count;
-	data.Shrink();
-}
-
-static StaticCriticalSection sImgMapLock;
-
-static VectorMap<String, Iml *>& sImgMap()
-{
-	static VectorMap<String, Iml *> x;
-	return x;
-}
-
-void Register(const char *imageclass, Iml& list)
-{
-#ifdef flagCHECKINIT
-	RLOG("Registering iml " << imageclass);
-#endif
-	INTERLOCKED_(sImgMapLock)
-		sImgMap().GetAdd(imageclass) = &list;
-}
-
-int GetImlCount()
-{
-	int q;
-	INTERLOCKED_(sImgMapLock)
-		q = sImgMap().GetCount();
-	return q;
-}
-
-Iml& GetIml(int i)
-{
-	return *sImgMap()[i];
-}
-
-String GetImlName(int i)
-{
-	DrawLock __;
-	return sImgMap().GetKey(i);
-}
-
-int FindIml(const char *name)
-{
-	DrawLock __;
-	return sImgMap().Find(name);
-}
-
-Image GetImlImage(const char *name)
-{
-	Image m;
-	const char *w = strchr(name, ':');
-	if(w) {
-		DrawLock __;
-		int q = FindIml(String(name, w));
-		if(q >= 0) {
-			Iml& iml = *sImgMap()[q];
-			while(*w == ':')
-				w++;
-			q = iml.Find(w);
-			if(q >= 0)
-				m = iml.Get(q);
-		}
-	}
-	return m;
-}
-
-void SetImlImage(const char *name, const Image& m)
-{
-	const char *w = strchr(name, ':');
-	if(w) {
-		DrawLock __;
-		int q = FindIml(String(name, w));
-		if(q >= 0) {
-			Iml& iml = *sImgMap()[q];
-			while(*w == ':')
-				w++;
-			q = iml.Find(w);
-			if(q >= 0)
-				iml.Set(q, m);
-		}
-	}
-}
-
-String StoreImageAsString(const Image& img)
-{
-	if(img.GetKind() == IMAGE_EMPTY)
-		return Null;
-	int type = img.GetKind() == IMAGE_OPAQUE ? 3 : 4;
-	StringStream ss;
-	ss.Put(type);
-	Size sz = img.GetSize();
-	ss.Put16le(sz.cx);
-	ss.Put16le(sz.cy);
-	Point p = img.GetHotSpot();
-	ss.Put16le(p.x);
-	ss.Put16le(p.y);
-	Size dots = img.GetDots();
-	ss.Put16le(dots.cx);
-	ss.Put16le(dots.cy);
-	const RGBA *s = img;
-	const RGBA *e = s + img.GetLength();
-	Buffer<byte> b(type * img.GetLength());
-	byte *t = b;
-	if(type == 3)
-		while(s < e) {
-			*t++ = s->r;
-			*t++ = s->g;
-			*t++ = s->b;
-			s++;
-		}
-	else
-		while(s < e) {
-			*t++ = s->r;
-			*t++ = s->g;
-			*t++ = s->b;
-			*t++ = s->a;
-			s++;
-		}
-	MemReadStream m(b, type * img.GetLength());
-	ZCompress(ss, m);
-	return ss;
-}
-
-Image  LoadImageFromString(const String& src)
-{
-	if(src.GetLength() < 13)
-		return Null;
-	StringStream ss(src);
-	int type = ss.Get();
-	Size sz;
-	sz.cx = ss.Get16le();
-	sz.cy = ss.Get16le();
-	if(sz.cx < 0 || sz.cy < 0)
-		return Null;
-	Point p;
-	p.x = ss.Get16le();
-	p.y = ss.Get16le();
-	if(p.x < 0 || p.y < 0)
-		return Null;
-	Size dots;
-	dots.cx = ss.Get16le();
-	dots.cy = ss.Get16le();
-	if(dots.cx < 0 || dots.cy < 0)
-		return Null;
-	StringStream out;
-	ZDecompress(out, ss);
-	String data = out;
-	if(data.GetLength() != type * sz.cx * sz.cy)
-		return Image();
-	ImageBuffer ib(sz);
-	ib.SetHotSpot(p);
-	ib.SetDots(dots);
-	RGBA *t = ib;
-	const RGBA *e = t + ib.GetLength();
-	const byte *s = data;
-	if(type == 3)
-		while(t < e) {
-			t->r = *s++;
-			t->g = *s++;
-			t->b = *s++;
-			t->a = 255;
-			t++;
-		}
-	else
-	if(type == 4)
-		while(t < e) {
-			t->r = *s++;
-			t->g = *s++;
-			t->b = *s++;
-			t->a = *s++;
-			t++;
-		}
-	else
-		return Image();
-	return ib;
-}
-
-Size GetImageStringSize(const String& src)
-{
-	if(src.GetLength() < 13)
-		return Size(0, 0);
-	StringStream ss(src);
-	ss.Get();
-	Size sz;
-	sz.cx = ss.Get16le();
-	sz.cy = ss.Get16le();
-	return sz;
-}
-
-Size GetImageStringDots(const String& src)
-{
-	if(src.GetLength() < 13)
-		return Size(0, 0);
-	StringStream ss(src);
-	ss.SeekCur(9);
-	Size sz;
-	sz.cx = ss.Get16le();
-	sz.cy = ss.Get16le();
-	return sz;
-}
-
-END_UPP_NAMESPACE
+#include "Draw.h"
+
+NAMESPACE_UPP
+
+#define LTIMING(x) // RTIMING(x)
+
+int ImageBuffer::ScanKind() const
+{
+	bool a255 = false;
+	bool a0 = false;
+	const RGBA *s = pixels;
+	const RGBA *e = s + GetLength();
+	while(s < e) {
+		if(s->a == 0)
+			a0 = true;
+		else
+		if(s->a == 255)
+			a255 = true;
+		else
+			return IMAGE_ALPHA;
+		s++;
+	}
+	return a255 ? a0 ? IMAGE_MASK : IMAGE_OPAQUE : IMAGE_EMPTY;
+}
+
+void ImageBuffer::SetHotSpots(const Image& src)
+{
+	SetHotSpot(src.GetHotSpot());
+	Set2ndSpot(src.Get2ndSpot());
+}
+
+void ImageBuffer::Create(int cx, int cy)
+{
+	ASSERT(cx >= 0 && cy >= 0);
+	size.cx = cx;
+	size.cy = cy;
+	pixels.Alloc(GetLength());
+#ifdef _DEBUG
+	RGBA *s = pixels;
+	RGBA *e = pixels + GetLength();
+	byte  a = 0;
+	while(s < e) {
+		s->a = a;
+		a = ~a;
+		s->r = 255;
+		s->g = s->b = 0;
+		s++;
+	}
+#endif
+	kind = IMAGE_UNKNOWN;
+	spot2 = hotspot = Point(0, 0);
+	dots = Size(0, 0);
+}
+
+void ImageBuffer::DeepCopy(const ImageBuffer& img)
+{
+	Create(img.GetSize());
+	SetHotSpot(img.GetHotSpot());
+	Set2ndSpot(img.Get2ndSpot());
+	SetDots(img.GetDots());
+	memcpy(pixels, img.pixels, GetLength() * sizeof(RGBA));
+}
+
+void ImageBuffer::Set(Image& img)
+{
+	if(img.data)
+		if(img.data->refcount == 1) {
+			size = img.GetSize();
+			kind = IMAGE_UNKNOWN;
+			hotspot = img.GetHotSpot();
+			spot2 = img.Get2ndSpot();
+			dots = img.GetDots();
+			pixels = img.data->buffer.pixels;
+			img.Clear();
+		}
+		else {
+			DeepCopy(img.data->buffer);
+			kind = IMAGE_UNKNOWN;
+			img.Clear();
+		}
+	else
+		Create(0, 0);
+}
+
+
+void ImageBuffer::operator=(Image& img)
+{
+	Clear();
+	Set(img);
+}
+
+void ImageBuffer::operator=(ImageBuffer& img)
+{
+	Clear();
+	Image m = img;
+	Set(m);
+}
+
+ImageBuffer::ImageBuffer(Image& img)
+{
+	Set(img);
+}
+
+ImageBuffer::ImageBuffer(ImageBuffer& b)
+{
+	kind = b.kind;
+	size = b.size;
+	dots = b.dots;
+	pixels = b.pixels;
+	hotspot = b.hotspot;
+	spot2 = b.spot2;
+}
+
+void ImageBuffer::SetDPI(Size dpi) 
+{
+	dots.cx = int(600.*size.cx/dpi.cx);
+	dots.cy = int(600.*size.cy/dpi.cy);
+}
+
+Size ImageBuffer::GetDPI() 
+{
+	return Size(dots.cx ? int(600.*size.cx/dots.cx) : 0, dots.cy ? int(600.*size.cy/dots.cy) : 0);
+}
+
+void  (Image::Data::*Image::Data::sSysInit)();
+void  (Image::Data::*Image::Data::sSysRelease)();
+int   (Image::Data::*Image::Data::sGetResCount)() const;
+void  (Image::Data::*Image::Data::sPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c);
+
+void Image::Data::InitSystemImage(
+	void  (Image::Data::*fSysInit)(),
+	void  (Image::Data::*fSysRelease)(),
+	int   (Image::Data::*fGetResCount)() const,
+	void  (Image::Data::*fPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c)
+)
+{
+	Image::Data::sSysInit = fSysInit;
+	Image::Data::sSysRelease = fSysRelease;
+	Image::Data::sGetResCount = fGetResCount;
+	Image::Data::sPaint = fPaint;
+}
+
+void Image::Data::SysInit()
+{
+	if(sSysInit)
+		(this->*sSysInit)();
+}
+
+void Image::Data::SysRelease()
+{
+	if(sSysRelease)
+		(this->*sSysRelease)();
+}
+
+int Image::Data::GetResCount() const
+{
+	if(sGetResCount)
+		return (this->*sGetResCount)();
+	return 0;
+}
+
+void Image::Data::Paint(SystemDraw& w, int x, int y, const Rect& src, Color c)
+{
+	if(sPaint)
+		(this->*sPaint)(w, x, y, src, c);
+}
+
+void Image::Set(ImageBuffer& b)
+{
+	if(b.GetWidth() == 0 || b.GetHeight() == 0)
+		data = NULL;
+	else
+		data = new Data(b);
+}
+
+void Image::Clear()
+{
+	if(data)
+		data->Release();
+	data = NULL;
+}
+
+Image& Image::operator=(ImageBuffer& img)
+{
+	if(data)
+		data->Release();
+	Set(img);
+	return *this;
+}
+
+Image& Image::operator=(const Image& img)
+{
+	Data *d = data;
+	data = img.data;
+	if(data)
+		data->Retain();
+	if(d)
+		d->Release();
+	return *this;
+}
+
+const RGBA* Image::operator~() const
+{
+	return data ? ~data->buffer : NULL;
+}
+
+Image::operator const RGBA*() const
+{
+	return data ? ~data->buffer : NULL;
+}
+
+const RGBA* Image::operator[](int i) const
+{
+	ASSERT(data);
+	return data->buffer[i];
+}
+
+Size Image::GetSize() const
+{
+	return data ? data->buffer.GetSize() : Size(0, 0);
+}
+
+int Image::GetLength() const
+{
+	return data ? data->buffer.GetLength() : 0;
+}
+
+Point Image::GetHotSpot() const
+{
+	return data ? data->buffer.GetHotSpot() : Point(0, 0);
+}
+
+Point Image::Get2ndSpot() const
+{
+	return data ? data->buffer.Get2ndSpot() : Point(0, 0);
+}
+
+Size Image::GetDots() const
+{
+	return data ? data->buffer.GetDots() : Size(0, 0);
+}
+
+Size Image::GetDPI() 
+{
+	Size size = GetSize();
+	Size dots = GetDots();
+	return data ?  Size(int(600.*size.cx/dots.cx), int(600.*size.cy/dots.cy)): Size(0, 0);
+}
+
+int Image::GetKindNoScan() const
+{
+	return data ? data->buffer.GetKind() : IMAGE_EMPTY;
+}
+
+int Image::Data::GetKind()
+{
+	int k = buffer.GetKind();
+	if(k != IMAGE_UNKNOWN)
+		return k;
+	k = buffer.ScanKind();
+	buffer.SetKind(k);
+	return k;
+}
+
+int Image::GetKind() const
+{
+	return data ? data->GetKind() : IMAGE_EMPTY;
+}
+
+void Image::PaintImage(SystemDraw& w, int x, int y, const Rect& src, Color c) const
+{
+	if(data)
+		data->Paint(w, x, y, src, c);
+}
+
+void Image::Serialize(Stream& s)
+{
+	int version = 0;
+	s / version;
+	Size sz = GetSize();
+	Point p = GetHotSpot();
+	Size dots = GetDots();
+	s % sz % p % dots;
+	int len = sz.cx * sz.cy;
+	if(s.IsLoading())
+		if(len) {
+			ImageBuffer b(sz);
+			if(!s.GetAll(~b, len * sizeof(RGBA)))
+				s.SetError();
+			b.SetDots(dots);
+			b.SetHotSpot(p);
+			*this = b;
+		}
+		else
+			Clear();
+	else
+		s.Put(~*this, len * sizeof(RGBA));
+}
+
+INITBLOCK {
+	Value::Register<Image>("Image");
+}
+
+bool Image::operator==(const Image& img) const
+{
+	if(GetLength() != img.GetLength())
+		return false;
+	return memcmp(~*this, ~img, GetLength() * sizeof(RGBA)) == 0;
+}
+
+bool Image::operator!=(const Image& img) const
+{
+	return !operator==(img);
+}
+
+dword Image::GetHashValue() const
+{
+	return memhash(~*this, GetLength() * sizeof(RGBA));
+}
+
+Image::Image(const Image& img)
+{
+	data = img.data;
+	if(data)
+		data->Retain();
+}
+
+Image::Image(Image (*fn)())
+{
+	data = NULL;
+	*this = (*fn)();
+}
+
+Image::Image(const Value& src)
+{
+	data = NULL;
+	if(!IsNull(src))
+		*this = RawValue<Image>::Extract(src);
+}
+
+Image::Image(ImageBuffer& b)
+{
+	Set(b);
+}
+
+Image::~Image()
+{
+	if(data)
+		data->Release();
+}
+
+Image::Image(const Init& init)
+{
+	ASSERT(init.info[0] >= 1);
+	Size sz;
+	sz.cx = Peek32le(init.info + 1);
+	sz.cy = Peek32le(init.info + 5);
+	ImageBuffer b(sz);
+	int i = 0;
+	while(i < init.scan_count) {
+		UnpackRLE(b[i], (const byte *)init.scans[i], sz.cx);
+		i++;
+	}
+	while(i < sz.cy)
+		memset(b[i++], 0, sizeof(RGBA) * sz.cx);
+	b.SetHotSpot(Point(Peek32le(init.info + 9), Peek32le(init.info + 13)));
+	Set(b);
+}
+
+String Image::ToString() const
+{
+	return String("Image ").Cat() << GetSize();
+}
+
+Link<Image::Data>     Image::Data::ResData[1];
+int                   Image::Data::ResCount;
+
+Image::Data::Data(ImageBuffer& b)
+:	buffer(b)
+{
+	paintcount = 0;
+	paintonly = false;
+	refcount = 1;
+	INTERLOCKED {
+		static int64 gserial;
+		serial = ++gserial;
+	}
+	SysInit();
+}
+
+Image::Data::~Data()
+{
+	DrawLock __;
+	SysRelease();
+	Unlink();
+}
+
+void Image::Data::PaintOnlyShrink()
+{
+	if(paintonly) {
+		LTIMING("PaintOnlyShrink");
+		DrawLock __;
+		DropPixels___(buffer);
+		ResCount -= GetResCount();
+		Unlink();
+	}
+}
+
+static void sMultiply(ImageBuffer& b, int (*op)(RGBA *t, const RGBA *s, int len))
+{
+	if(b.GetKind() != IMAGE_OPAQUE && b.GetKind() != IMAGE_EMPTY)
+		(*op)(~b, ~b, b.GetLength());
+}
+
+void Premultiply(ImageBuffer& b)
+{
+	sMultiply(b, Premultiply);
+}
+
+void Unmultiply(ImageBuffer& b)
+{
+	sMultiply(b, Unmultiply);
+}
+
+static Image sMultiply(const Image& img, int (*op)(RGBA *t, const RGBA *s, int len))
+{
+	int k = img.GetKind();
+	if(k == IMAGE_OPAQUE || k == IMAGE_EMPTY)
+		return img;
+	ImageBuffer ib(img.GetSize());
+	ib.SetHotSpot(img.GetHotSpot());
+	ib.Set2ndSpot(img.Get2ndSpot());
+	ib.SetKind(Premultiply(~ib, ~img, ib.GetLength()));
+	return ib;
+}
+
+Image Premultiply(const Image& img)
+{
+	return sMultiply(img, Premultiply);
+}
+
+Image Unmultiply(const Image& img)
+{
+	return sMultiply(img, Unmultiply);
+}
+
+void SetPaintOnly___(Image& m)
+{
+	if(m.data && m.data->refcount == 1)
+		m.data->paintonly = true;
+}
+
+void Iml::Init(int n)
+{
+	for(int i = 0; i < n; i++)
+		map.Add(name[i]);
+}
+
+void Iml::Reset()
+{
+	int n = map.GetCount();
+	map.Clear();
+	Init(n);
+}
+
+void Iml::Set(int i, const Image& img)
+{
+	map[i].image = img;
+	map[i].loaded = true;
+}
+
+Image Iml::Get(int i)
+{
+	IImage& m = map[i];
+	if(!m.loaded) {
+		DrawLock __;
+		if(data.GetCount()) {
+			int ii = 0;
+			for(;;) {
+				const Data& d = data[ii];
+				if(i < d.count) {
+					static const char   *cached_data;
+					static Vector<Image> cached;
+					if(cached_data != d.data) {
+						cached_data = d.data;
+						cached = UnpackImlData(d.data, d.len);
+						if(premultiply)
+							for(int i = 0; i < cached.GetCount(); i++)
+								cached[i] = Premultiply(cached[i]);
+					}
+					m.image = cached[i];
+					break;
+				}
+				i -= d.count;
+				ii++;
+			}
+		}
+		else
+			m.image = Premultiply(Image(img_init[i]));
+		m.loaded = true;
+	}
+	return m.image;
+}
+
+#ifdef _DEBUG
+int  Iml::GetBinSize() const
+{
+	int size = 0;
+	for(int i = 0; i < map.GetCount(); i++) {
+		const Image::Init& init = img_init[i];
+		size += (int)strlen(name[i]) + 1 + 24;
+		for(int q = 0; q < init.scan_count; q++)
+			size += (int)strlen(init.scans[q]);
+	}
+	return size;
+}
+#endif
+
+Iml::Iml(const Image::Init *img_init, const char **name, int n)
+:	img_init(img_init),
+	name(name)
+{
+#ifdef flagCHECKINIT
+	RLOG("Constructing iml " << *name);
+#endif
+	premultiply = true;
+	Init(n);
+}
+
+void Iml::AddData(const byte *_data, int len, int count)
+{
+	Data& d = data.Add();
+	d.data = (const char *)_data;
+	d.len = len;
+	d.count = count;
+	data.Shrink();
+}
+
+static StaticCriticalSection sImgMapLock;
+
+static VectorMap<String, Iml *>& sImgMap()
+{
+	static VectorMap<String, Iml *> x;
+	return x;
+}
+
+void Register(const char *imageclass, Iml& list)
+{
+#ifdef flagCHECKINIT
+	RLOG("Registering iml " << imageclass);
+#endif
+	INTERLOCKED_(sImgMapLock)
+		sImgMap().GetAdd(imageclass) = &list;
+}
+
+int GetImlCount()
+{
+	int q;
+	INTERLOCKED_(sImgMapLock)
+		q = sImgMap().GetCount();
+	return q;
+}
+
+Iml& GetIml(int i)
+{
+	return *sImgMap()[i];
+}
+
+String GetImlName(int i)
+{
+	DrawLock __;
+	return sImgMap().GetKey(i);
+}
+
+int FindIml(const char *name)
+{
+	DrawLock __;
+	return sImgMap().Find(name);
+}
+
+Image GetImlImage(const char *name)
+{
+	Image m;
+	const char *w = strchr(name, ':');
+	if(w) {
+		DrawLock __;
+		int q = FindIml(String(name, w));
+		if(q >= 0) {
+			Iml& iml = *sImgMap()[q];
+			while(*w == ':')
+				w++;
+			q = iml.Find(w);
+			if(q >= 0)
+				m = iml.Get(q);
+		}
+	}
+	return m;
+}
+
+void SetImlImage(const char *name, const Image& m)
+{
+	const char *w = strchr(name, ':');
+	if(w) {
+		DrawLock __;
+		int q = FindIml(String(name, w));
+		if(q >= 0) {
+			Iml& iml = *sImgMap()[q];
+			while(*w == ':')
+				w++;
+			q = iml.Find(w);
+			if(q >= 0)
+				iml.Set(q, m);
+		}
+	}
+}
+
+String StoreImageAsString(const Image& img)
+{
+	if(img.GetKind() == IMAGE_EMPTY)
+		return Null;
+	int type = img.GetKind() == IMAGE_OPAQUE ? 3 : 4;
+	StringStream ss;
+	ss.Put(type);
+	Size sz = img.GetSize();
+	ss.Put16le(sz.cx);
+	ss.Put16le(sz.cy);
+	Point p = img.GetHotSpot();
+	ss.Put16le(p.x);
+	ss.Put16le(p.y);
+	Size dots = img.GetDots();
+	ss.Put16le(dots.cx);
+	ss.Put16le(dots.cy);
+	const RGBA *s = img;
+	const RGBA *e = s + img.GetLength();
+	Buffer<byte> b(type * img.GetLength());
+	byte *t = b;
+	if(type == 3)
+		while(s < e) {
+			*t++ = s->r;
+			*t++ = s->g;
+			*t++ = s->b;
+			s++;
+		}
+	else
+		while(s < e) {
+			*t++ = s->r;
+			*t++ = s->g;
+			*t++ = s->b;
+			*t++ = s->a;
+			s++;
+		}
+	MemReadStream m(b, type * img.GetLength());
+	ZCompress(ss, m);
+	return ss;
+}
+
+Image  LoadImageFromString(const String& src)
+{
+	if(src.GetLength() < 13)
+		return Null;
+	StringStream ss(src);
+	int type = ss.Get();
+	Size sz;
+	sz.cx = ss.Get16le();
+	sz.cy = ss.Get16le();
+	if(sz.cx < 0 || sz.cy < 0)
+		return Null;
+	Point p;
+	p.x = ss.Get16le();
+	p.y = ss.Get16le();
+	if(p.x < 0 || p.y < 0)
+		return Null;
+	Size dots;
+	dots.cx = ss.Get16le();
+	dots.cy = ss.Get16le();
+	if(dots.cx < 0 || dots.cy < 0)
+		return Null;
+	StringStream out;
+	ZDecompress(out, ss);
+	String data = out;
+	if(data.GetLength() != type * sz.cx * sz.cy)
+		return Image();
+	ImageBuffer ib(sz);
+	ib.SetHotSpot(p);
+	ib.SetDots(dots);
+	RGBA *t = ib;
+	const RGBA *e = t + ib.GetLength();
+	const byte *s = data;
+	if(type == 3)
+		while(t < e) {
+			t->r = *s++;
+			t->g = *s++;
+			t->b = *s++;
+			t->a = 255;
+			t++;
+		}
+	else
+	if(type == 4)
+		while(t < e) {
+			t->r = *s++;
+			t->g = *s++;
+			t->b = *s++;
+			t->a = *s++;
+			t++;
+		}
+	else
+		return Image();
+	return ib;
+}
+
+Size GetImageStringSize(const String& src)
+{
+	if(src.GetLength() < 13)
+		return Size(0, 0);
+	StringStream ss(src);
+	ss.Get();
+	Size sz;
+	sz.cx = ss.Get16le();
+	sz.cy = ss.Get16le();
+	return sz;
+}
+
+Size GetImageStringDots(const String& src)
+{
+	if(src.GetLength() < 13)
+		return Size(0, 0);
+	StringStream ss(src);
+	ss.SeekCur(9);
+	Size sz;
+	sz.cx = ss.Get16le();
+	sz.cy = ss.Get16le();
+	return sz;
+}
+
+END_UPP_NAMESPACE
diff --git a/uppsrc/Draw/Image.h b/uppsrc/Draw/Image.h
index cb3ed23dc..9d8d3ba94 100644
--- a/uppsrc/Draw/Image.h
+++ b/uppsrc/Draw/Image.h
@@ -1,343 +1,347 @@
-#define NEWIMAGE
-
-enum ImageKind {
-	IMAGE_UNKNOWN,
-	IMAGE_EMPTY,
-	IMAGE_ALPHA,
-	IMAGE_MASK,
-	IMAGE_OPAQUE,
-};
-
-inline bool operator==(const RGBA& a, const RGBA& b)
-{
-	return a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a;
-}
-
-inline bool operator!=(const RGBA& a, const RGBA& b)
-{
-	return !(a == b);
-}
-
-inline RGBA RGBAZero() { RGBA c; c.r = c.g = c.b = c.a = 0; return c; }
-
-void Fill(RGBA *t, const RGBA& src, int n);
-void FillColor(RGBA *t, const RGBA& src, int n);
-
-void Copy(RGBA *t, const RGBA *s, int n);
-
-int  Premultiply(RGBA *t, const RGBA *s, int len);
-int  Unmultiply(RGBA *t, const RGBA *s, int len);
-
-void TransformComponents(RGBA *t, const RGBA *s, int len,
-	const byte r[], const byte g[], const byte b[], const byte a[]);
-void MultiplyComponents(RGBA *t, const RGBA *s, int len, int num, int den = 256);
-
-void AlphaBlend(RGBA *t, const RGBA *s, int len);
-void AlphaBlend(RGBA *t, const RGBA *s, int len, Color color);
-
-void AlphaBlendOpaque(RGBA *t, const RGBA *s, int len, Color color);
-void AlphaBlendOpaque(RGBA *t, const RGBA *s, int len);
-
-void AlphaBlendStraight(RGBA *b, const RGBA *f, int len);
-void AlphaBlendStraight(RGBA *b, const RGBA *f, int len, Color color);
-void AlphaBlendStraightOpaque(RGBA *t, const RGBA *s, int len);
-void AlphaBlendStraightOpaque(RGBA *t, const RGBA *s, int len, int alpha);
-
-int  GetChMaskPos32(dword mask);
-void AlphaBlendOverBgST(RGBA *b, RGBA bg, int len);
-
-const byte *UnpackRLE(RGBA *t, const byte *src, int len);
-String      PackRLE(const RGBA *s, int len);
-
-inline int  Grayscale(int r, int g, int b) { return (77 * r + 151 * g + 28 * b) >> 8; }
-inline int  Grayscale(const RGBA& c)       { return Grayscale(c.r, c.g, c.b); }
-inline byte Saturate255(int x)             { return byte(~(x >> 24) & (x | (-(x >> 8) >> 24)) & 0xff); }
-
-class  Image;
-
-class ImageBuffer : NoCopy {
-	mutable int  kind;
-	Size         size;
-	Buffer<RGBA> pixels;
-	Point        hotspot;
-	Point        spot2;
-	Size         dots;
-
-	void         Set(Image& img);
-	void         DeepCopy(const ImageBuffer& img);
-
-	RGBA*        Line(int i) const      { ASSERT(i >= 0 && i < size.cy); return (RGBA *)~pixels + i * size.cx; }
-	friend void  DropPixels___(ImageBuffer& b) { b.pixels.Clear(); }
-
-	friend class Image;
-
-public:
-	void  SetKind(int k)                { kind = k; }
-	int   GetKind() const               { return kind; }
-	int   ScanKind() const;
-	int   GetScanKind() const           { return kind == IMAGE_UNKNOWN ? ScanKind() : kind; }
-
-	void  SetHotSpot(Point p)           { hotspot = p; }
-	Point GetHotSpot() const            { return hotspot; }
-
-	void  Set2ndSpot(Point p)           { spot2 = p; }
-	Point Get2ndSpot() const            { return spot2; }
-	
-	void  SetHotSpots(const Image& src);
-
-	void  SetDots(Size sz)              { dots = sz; }
-	Size  GetDots() const               { return dots; }
-	void  SetDPI(Size sz);
-	Size  GetDPI();
-
-	Size  GetSize() const               { return size; }
-	int   GetWidth() const              { return size.cx; }
-	int   GetHeight() const             { return size.cy; }
-	int   GetLength() const             { return size.cx * size.cy; }
-
-	RGBA *operator[](int i)             { return Line(i); }
-	const RGBA *operator[](int i) const { return Line(i); }
-	RGBA *operator~()                   { return pixels; }
-	operator RGBA*()                    { return pixels; }
-	const RGBA *operator~() const       { return pixels; }
-	operator const RGBA*() const        { return pixels; }
-	RGBA *Begin()                       { return pixels; }
-	const RGBA *Begin() const           { return pixels; }
-	RGBA *End()                         { return pixels + GetLength(); }
-	const RGBA *End() const             { return pixels + GetLength(); }
-
-	void  Create(int cx, int cy);
-	void  Create(Size sz)               { Create(sz.cx, sz.cy); }
-	bool  IsEmpty() const               { return (size.cx | size.cy) == 0; }
-	void  Clear()                       { Create(0, 0); }
-
-	void  operator=(Image& img);
-	void  operator=(ImageBuffer& img);
-
-	ImageBuffer()                       { Create(0, 0); }
-	ImageBuffer(int cx, int cy)         { Create(cx, cy); }
-	ImageBuffer(Size sz)                { Create(sz.cx, sz.cy); }
-	ImageBuffer(Image& img);
-	ImageBuffer(ImageBuffer& b);
-// BW, defined in CtrlCore:
-	ImageBuffer(ImageDraw& iw);
-};
-
-void Premultiply(ImageBuffer& b);
-void Unmultiply(ImageBuffer& b);
-
-class Image : public AssignValueTypeNo< Image, 150, Moveable<Image> > {
-private:
-	struct Data : Link<Data> {
-		Atomic refcount;
-		int64  serial;
-		int    paintcount;
-
-		static Link<Data>            ResData[1];
-		static int                   ResCount;
-
-		void   Retain()  { AtomicInc(refcount); }
-		void   Release() { if(AtomicDec(refcount) == 0) delete this; }
-		
-		struct SystemData;
-		
-		void  *system_buffer[6];
-		SystemData& Sys() const;
-
-#ifdef PLATFORM_WIN32
-		void CreateHBMP(HDC dc, const RGBA *data);
-#endif
-
-		ImageBuffer buffer;
-		bool        paintonly;
-		
-		void        SysInitImp();
-		void        SysReleaseImp();
-		int         GetResCountImp() const;
-		void        PaintImp(SystemDraw& w, int x, int y, const Rect& src, Color c);
-
-		void        SysInit();
-		void        SysRelease();
-		int         GetResCount() const;
-		void        Paint(SystemDraw& w, int x, int y, const Rect& src, Color c);
-
-		int         GetKind();
-		void        PaintOnlyShrink();
-
-		Data(ImageBuffer& b);
-		~Data();
-		
-		static void  (Image::Data::*sSysInit)();
-		static void  (Image::Data::*sSysRelease)();
-		static int   (Image::Data::*sGetResCount)() const;
-		static void  (Image::Data::*sPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c);
-
-		friend void InstallSystemImage();
-		static void InitSystemImage(
-			void  (Image::Data::*fSysInit)(),
-			void  (Image::Data::*fSysRelease)(),
-			int   (Image::Data::*fGetResCount)() const,
-			void  (Image::Data::*fPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c)
-		);
-	};
-
-	Data *data;
-
-	static Link<Image::Data>     ResData[1];
-	static int                   ResCount;
-
-	void Set(ImageBuffer& b);
-
-	friend class ImageBuffer;
-	friend struct Data;
-
-	friend void SetPaintOnly___(Image& m);
-	friend void DrawImageBandRLE(Draw& w, int x, int y, const Image& m, int minp);
-	friend void InstallSystemImage();
-
-#ifdef PLATFORM_WIN32
-#ifndef PLATFORM_WINCE
-	void         SetCursorCheat(LPCSTR id);
-	LPCSTR       GetCursorCheat() const;
-	friend Image Win32IconCursor(LPCSTR id, int iconsize, bool cursor);
-	friend HICON IconWin32(const Image& img, bool cursor);
-#endif
-#endif
-
-#ifdef PLATFORM_POSIX // These are only implemented for X11...
-	void         SetCursorCheat(int id);
-	int          GetCursorCheat() const;
-	friend       void *CursorX11(const Image&);
-	friend       Image X11Cursor(int c);
-#endif
-
-public:
-	const RGBA*    operator~() const;
-	operator const RGBA*() const;
-	const RGBA* operator[](int i) const;
-
-	Size  GetSize() const;
-	int   GetWidth() const                    { return GetSize().cx; }
-	int   GetHeight() const                   { return GetSize().cy; }
-	int   GetLength() const;
-	Point GetHotSpot() const;
-	Point Get2ndSpot() const;
-	Size  GetDots() const;
-	Size  GetDPI();	
-	int   GetKindNoScan() const;
-	int   GetKind() const;
-
-	int64 GetSerialId() const                 { return data ? data->serial : 0; }
-	bool  IsSame(const Image& img) const      { return GetSerialId() == img.GetSerialId(); }
-
-	bool   operator==(const Image& img) const;
-	bool   operator!=(const Image& img) const;
-	dword  GetHashValue() const;
-	String ToString() const;
-
-	void  Serialize(Stream& s);
-	void  Clear();
-
-	Image& operator=(const Image& img);
-	Image& operator=(ImageBuffer& img);
-
-	bool IsNullInstance() const         { Size sz = GetSize(); return (sz.cx|sz.cy) == 0; }
-
-	bool IsEmpty() const                { return IsNullInstance(); }
-	operator Value() const              { return RichValue<Image>(*this); }
-
-	Image()                             { data = NULL; }
-	Image(const Nuller&)                { data = NULL; }
-	Image(const Value& src);
-	Image(const Image& img);
-	Image(Image (*fn)());
-	Image(ImageBuffer& b);
-	~Image();
-
-	void PaintImage(SystemDraw& w, int x, int y, const Rect& src, Color c) const;
-
-	static Image Arrow();
-	static Image Wait();
-	static Image IBeam();
-	static Image No();
-	static Image SizeAll();
-	static Image SizeHorz();
-	static Image SizeVert();
-	static Image SizeTopLeft();
-	static Image SizeTop();
-	static Image SizeTopRight();
-	static Image SizeLeft();
-	static Image SizeRight();
-	static Image SizeBottomLeft();
-	static Image SizeBottom();
-	static Image SizeBottomRight();
-	static Image Cross();
-	static Image Hand();
-
-	// IML support ("private"), deprecated - legacy .iml
-	struct Init {
-		const char *const *scans;
-		int16 scan_count;
-		char info[24];
-	};
-	explicit Image(const Init& init);
-};
-
-Image Premultiply(const Image& img);
-Image Unmultiply(const Image& img);
-
-Vector<Image> UnpackImlData(const void *ptr, int len);
-Vector<Image> UnpackImlData(const String& d);
-
-class Iml {
-	struct IImage : Moveable<IImage> {
-		bool  loaded;
-		Image image;
-
-		IImage() { loaded = false; }
-	};
-	struct Data : Moveable<Data> {
-		const char *data;
-		int   len, count;
-	};
-	Vector<Data> data;
-	VectorMap<String, IImage> map;
-	const Image::Init *img_init;
-	const char **name;
-	bool  premultiply;
-
-	void  Init(int n);
-
-public:
-	void   Reset();
-	int    GetCount() const                  { return map.GetCount(); }
-	String GetId(int i)                      { return map.GetKey(i); }
-	Image  Get(int i);
-	int    Find(const String& s) const       { return map.Find(s); }
-	void   Set(int i, const Image& img);
-	void   Premultiplied()                   { premultiply = false; }
-
-#ifdef _DEBUG
-	int    GetBinSize() const;
-#endif
-
-	Iml(const Image::Init *img_init, const char **name, int n);//Deprecated - legacy .iml
-	void AddData(const byte *data, int len, int count);
-};
-
-void   Register(const char *imageclass, Iml& iml);
-
-int    GetImlCount();
-String GetImlName(int i);
-Iml&   GetIml(int i);
-int    FindIml(const char *name);
-Image  GetImlImage(const char *name);
-void   SetImlImage(const char *name, const Image& m);
-
-String StoreImageAsString(const Image& img);
-Image  LoadImageFromString(const String& s);
-Size   GetImageStringSize(const String& src);
-Size   GetImageStringDots(const String& src);
-
-#include "Raster.h"
-#include "ImageOp.h"
+#define NEWIMAGE
+
+enum ImageKind {
+	IMAGE_UNKNOWN,
+	IMAGE_EMPTY,
+	IMAGE_ALPHA,
+	IMAGE_MASK,
+	IMAGE_OPAQUE,
+};
+
+inline bool operator==(const RGBA& a, const RGBA& b)
+{
+	return a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a;
+}
+
+inline bool operator!=(const RGBA& a, const RGBA& b)
+{
+	return !(a == b);
+}
+
+inline RGBA RGBAZero() { RGBA c; c.r = c.g = c.b = c.a = 0; return c; }
+
+void Fill(RGBA *t, const RGBA& src, int n);
+void FillColor(RGBA *t, const RGBA& src, int n);
+
+void Copy(RGBA *t, const RGBA *s, int n);
+
+int  Premultiply(RGBA *t, const RGBA *s, int len);
+int  Unmultiply(RGBA *t, const RGBA *s, int len);
+
+void TransformComponents(RGBA *t, const RGBA *s, int len,
+	const byte r[], const byte g[], const byte b[], const byte a[]);
+void MultiplyComponents(RGBA *t, const RGBA *s, int len, int num, int den = 256);
+
+void AlphaBlend(RGBA *t, const RGBA *s, int len);
+void AlphaBlend(RGBA *t, const RGBA *s, int len, Color color);
+
+void AlphaBlendOpaque(RGBA *t, const RGBA *s, int len, Color color);
+void AlphaBlendOpaque(RGBA *t, const RGBA *s, int len);
+
+void AlphaBlendStraight(RGBA *b, const RGBA *f, int len);
+void AlphaBlendStraight(RGBA *b, const RGBA *f, int len, Color color);
+void AlphaBlendStraightOpaque(RGBA *t, const RGBA *s, int len);
+void AlphaBlendStraightOpaque(RGBA *t, const RGBA *s, int len, int alpha);
+
+int  GetChMaskPos32(dword mask);
+void AlphaBlendOverBgST(RGBA *b, RGBA bg, int len);
+
+const byte *UnpackRLE(RGBA *t, const byte *src, int len);
+String      PackRLE(const RGBA *s, int len);
+
+inline int  Grayscale(int r, int g, int b) { return (77 * r + 151 * g + 28 * b) >> 8; }
+inline int  Grayscale(const RGBA& c)       { return Grayscale(c.r, c.g, c.b); }
+inline byte Saturate255(int x)             { return byte(~(x >> 24) & (x | (-(x >> 8) >> 24)) & 0xff); }
+
+class  Image;
+
+class ImageBuffer : NoCopy {
+	mutable int  kind;
+	Size         size;
+	Buffer<RGBA> pixels;
+	Point        hotspot;
+	Point        spot2;
+	Size         dots;
+
+	void         Set(Image& img);
+	void         DeepCopy(const ImageBuffer& img);
+
+	RGBA*        Line(int i) const      { ASSERT(i >= 0 && i < size.cy); return (RGBA *)~pixels + i * size.cx; }
+	friend void  DropPixels___(ImageBuffer& b) { b.pixels.Clear(); }
+
+	friend class Image;
+
+public:
+	void  SetKind(int k)                { kind = k; }
+	int   GetKind() const               { return kind; }
+	int   ScanKind() const;
+	int   GetScanKind() const           { return kind == IMAGE_UNKNOWN ? ScanKind() : kind; }
+
+	void  SetHotSpot(Point p)           { hotspot = p; }
+	Point GetHotSpot() const            { return hotspot; }
+
+	void  Set2ndSpot(Point p)           { spot2 = p; }
+	Point Get2ndSpot() const            { return spot2; }
+	
+	void  SetHotSpots(const Image& src);
+
+	void  SetDots(Size sz)              { dots = sz; }
+	Size  GetDots() const               { return dots; }
+	void  SetDPI(Size sz);
+	Size  GetDPI();
+
+	Size  GetSize() const               { return size; }
+	int   GetWidth() const              { return size.cx; }
+	int   GetHeight() const             { return size.cy; }
+	int   GetLength() const             { return size.cx * size.cy; }
+
+	RGBA *operator[](int i)             { return Line(i); }
+	const RGBA *operator[](int i) const { return Line(i); }
+	RGBA *operator~()                   { return pixels; }
+	operator RGBA*()                    { return pixels; }
+	const RGBA *operator~() const       { return pixels; }
+	operator const RGBA*() const        { return pixels; }
+	RGBA *Begin()                       { return pixels; }
+	const RGBA *Begin() const           { return pixels; }
+	RGBA *End()                         { return pixels + GetLength(); }
+	const RGBA *End() const             { return pixels + GetLength(); }
+
+	void  Create(int cx, int cy);
+	void  Create(Size sz)               { Create(sz.cx, sz.cy); }
+	bool  IsEmpty() const               { return (size.cx | size.cy) == 0; }
+	void  Clear()                       { Create(0, 0); }
+
+	void  operator=(Image& img);
+	void  operator=(ImageBuffer& img);
+
+	ImageBuffer()                       { Create(0, 0); }
+	ImageBuffer(int cx, int cy)         { Create(cx, cy); }
+	ImageBuffer(Size sz)                { Create(sz.cx, sz.cy); }
+	ImageBuffer(Image& img);
+	ImageBuffer(ImageBuffer& b);
+// BW, defined in CtrlCore:
+	ImageBuffer(ImageDraw& iw);
+};
+
+void Premultiply(ImageBuffer& b);
+void Unmultiply(ImageBuffer& b);
+
+class Image : public ValueType< Image, 150, Moveable<Image> > {
+private:
+	struct Data : Link<Data> {
+		Atomic refcount;
+		int64  serial;
+		int    paintcount;
+
+		static Link<Data>            ResData[1];
+		static int                   ResCount;
+
+		void   Retain()  { AtomicInc(refcount); }
+		void   Release() { if(AtomicDec(refcount) == 0) delete this; }
+		
+		struct SystemData;
+		
+		void  *system_buffer[6];
+		SystemData& Sys() const;
+
+#ifdef PLATFORM_WIN32
+		void CreateHBMP(HDC dc, const RGBA *data);
+#endif
+
+		ImageBuffer buffer;
+		bool        paintonly;
+		
+		void        SysInitImp();
+		void        SysReleaseImp();
+		int         GetResCountImp() const;
+		void        PaintImp(SystemDraw& w, int x, int y, const Rect& src, Color c);
+
+		void        SysInit();
+		void        SysRelease();
+		int         GetResCount() const;
+		void        Paint(SystemDraw& w, int x, int y, const Rect& src, Color c);
+
+		int         GetKind();
+		void        PaintOnlyShrink();
+
+		Data(ImageBuffer& b);
+		~Data();
+		
+		static void  (Image::Data::*sSysInit)();
+		static void  (Image::Data::*sSysRelease)();
+		static int   (Image::Data::*sGetResCount)() const;
+		static void  (Image::Data::*sPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c);
+
+		friend void InstallSystemImage();
+		static void InitSystemImage(
+			void  (Image::Data::*fSysInit)(),
+			void  (Image::Data::*fSysRelease)(),
+			int   (Image::Data::*fGetResCount)() const,
+			void  (Image::Data::*fPaint)(SystemDraw& w, int x, int y, const Rect& src, Color c)
+		);
+	};
+
+	Data *data;
+
+	static Link<Image::Data>     ResData[1];
+	static int                   ResCount;
+
+	void Set(ImageBuffer& b);
+
+	friend class ImageBuffer;
+	friend struct Data;
+
+	friend void SetPaintOnly___(Image& m);
+	friend void DrawImageBandRLE(Draw& w, int x, int y, const Image& m, int minp);
+	friend void InstallSystemImage();
+
+#ifdef PLATFORM_WIN32
+#ifndef PLATFORM_WINCE
+	void         SetCursorCheat(LPCSTR id);
+	LPCSTR       GetCursorCheat() const;
+	friend Image Win32IconCursor(LPCSTR id, int iconsize, bool cursor);
+	friend HICON IconWin32(const Image& img, bool cursor);
+#endif
+#endif
+
+#ifdef PLATFORM_POSIX // These are only implemented for X11...
+	void         SetCursorCheat(int id);
+	int          GetCursorCheat() const;
+	friend       void *CursorX11(const Image&);
+	friend       Image X11Cursor(int c);
+#endif
+
+public:
+	const RGBA*    operator~() const;
+	operator const RGBA*() const;
+	const RGBA* operator[](int i) const;
+
+	Size  GetSize() const;
+	int   GetWidth() const                    { return GetSize().cx; }
+	int   GetHeight() const                   { return GetSize().cy; }
+	int   GetLength() const;
+	Point GetHotSpot() const;
+	Point Get2ndSpot() const;
+	Size  GetDots() const;
+	Size  GetDPI();	
+	int   GetKindNoScan() const;
+	int   GetKind() const;
+
+	int64 GetSerialId() const                 { return data ? data->serial : 0; }
+	bool  IsSame(const Image& img) const      { return GetSerialId() == img.GetSerialId(); }
+
+	bool   operator==(const Image& img) const;
+	bool   operator!=(const Image& img) const;
+	dword  GetHashValue() const;
+	String ToString() const;
+
+	void  Serialize(Stream& s);
+#ifdef SVO_VALUE
+	void Xmlize(XmlIO& xio)                   { XmlizeBySerialize(xio, *this); }
+	void Jsonize(JsonIO& jio)                 { JsonizeBySerialize(jio, *this); }
+#endif
+	void  Clear();
+
+	Image& operator=(const Image& img);
+	Image& operator=(ImageBuffer& img);
+
+	bool IsNullInstance() const         { Size sz = GetSize(); return (sz.cx|sz.cy) == 0; }
+
+	bool IsEmpty() const                { return IsNullInstance(); }
+	operator Value() const              { return RichValue<Image>(*this); }
+
+	Image()                             { data = NULL; }
+	Image(const Nuller&)                { data = NULL; }
+	Image(const Value& src);
+	Image(const Image& img);
+	Image(Image (*fn)());
+	Image(ImageBuffer& b);
+	~Image();
+
+	void PaintImage(SystemDraw& w, int x, int y, const Rect& src, Color c) const;
+
+	static Image Arrow();
+	static Image Wait();
+	static Image IBeam();
+	static Image No();
+	static Image SizeAll();
+	static Image SizeHorz();
+	static Image SizeVert();
+	static Image SizeTopLeft();
+	static Image SizeTop();
+	static Image SizeTopRight();
+	static Image SizeLeft();
+	static Image SizeRight();
+	static Image SizeBottomLeft();
+	static Image SizeBottom();
+	static Image SizeBottomRight();
+	static Image Cross();
+	static Image Hand();
+
+	// IML support ("private"), deprecated - legacy .iml
+	struct Init {
+		const char *const *scans;
+		int16 scan_count;
+		char info[24];
+	};
+	explicit Image(const Init& init);
+};
+
+Image Premultiply(const Image& img);
+Image Unmultiply(const Image& img);
+
+Vector<Image> UnpackImlData(const void *ptr, int len);
+Vector<Image> UnpackImlData(const String& d);
+
+class Iml {
+	struct IImage : Moveable<IImage> {
+		bool  loaded;
+		Image image;
+
+		IImage() { loaded = false; }
+	};
+	struct Data : Moveable<Data> {
+		const char *data;
+		int   len, count;
+	};
+	Vector<Data> data;
+	VectorMap<String, IImage> map;
+	const Image::Init *img_init;
+	const char **name;
+	bool  premultiply;
+
+	void  Init(int n);
+
+public:
+	void   Reset();
+	int    GetCount() const                  { return map.GetCount(); }
+	String GetId(int i)                      { return map.GetKey(i); }
+	Image  Get(int i);
+	int    Find(const String& s) const       { return map.Find(s); }
+	void   Set(int i, const Image& img);
+	void   Premultiplied()                   { premultiply = false; }
+
+#ifdef _DEBUG
+	int    GetBinSize() const;
+#endif
+
+	Iml(const Image::Init *img_init, const char **name, int n);//Deprecated - legacy .iml
+	void AddData(const byte *data, int len, int count);
+};
+
+void   Register(const char *imageclass, Iml& iml);
+
+int    GetImlCount();
+String GetImlName(int i);
+Iml&   GetIml(int i);
+int    FindIml(const char *name);
+Image  GetImlImage(const char *name);
+void   SetImlImage(const char *name, const Image& m);
+
+String StoreImageAsString(const Image& img);
+Image  LoadImageFromString(const String& s);
+Size   GetImageStringSize(const String& src);
+Size   GetImageStringDots(const String& src);
+
+#include "Raster.h"
+#include "ImageOp.h"
diff --git a/uppsrc/Ole/util.h b/uppsrc/Ole/util.h
index 603a38fc0..54a53edd8 100644
--- a/uppsrc/Ole/util.h
+++ b/uppsrc/Ole/util.h
@@ -44,7 +44,7 @@ String                GetDisplayName(const GUID& guid);
 template <> bool      IsNull(const GUID& guid);
 GUID                  GetCoClassGUID(const char *name, bool prog_id = true);
 
-class Guid : public AssignValueTypeNo<Guid, 70, Moveable<Guid> >
+class Guid : public ValueType<Guid, 70, Moveable<Guid> >
 {
 public:
 	Guid(const Nuller& = Null)               { Clear(); }
diff --git a/uppsrc/Sql/Sqls.h b/uppsrc/Sql/Sqls.h
index 7726bac8d..c3f3955c3 100644
--- a/uppsrc/Sql/Sqls.h
+++ b/uppsrc/Sql/Sqls.h
@@ -19,7 +19,7 @@ public:
 
 enum { SQLRAW_V = 34 };
 
-class SqlRaw : public String, AssignValueTypeNo<SqlRaw, SQLRAW_V> {
+class SqlRaw : public String, ValueType<SqlRaw, SQLRAW_V> {
 public:
 	operator Value() const              { return RawValue<SqlRaw>(*this); }
 	SqlRaw(const Value& q)