diff --git a/uppsrc/Core/Core.h b/uppsrc/Core/Core.h
index 230ef88..74f54a2 100644
--- a/uppsrc/Core/Core.h
+++ b/uppsrc/Core/Core.h
@@ -168,6 +168,7 @@
 
 #include <algorithm>
 #include <string>
+#include <complex>
 
 // fix MSC8 beta problem....
 #ifdef COMPILER_MSC
diff --git a/uppsrc/Core/Defs.h b/uppsrc/Core/Defs.h
index e41e407..8e2213a 100644
--- a/uppsrc/Core/Defs.h
+++ b/uppsrc/Core/Defs.h
@@ -247,6 +247,8 @@ typedef long long unsigned uint64;
 
 typedef uint64             qword;
 
+typedef std::complex<double> cdouble;
+
 #ifdef COMPILER_MSC
 	#define I64(c) ((int64)COMBINE(c, i64))
 #else
@@ -325,6 +327,40 @@ public:
 	NoCopy() {}
 };
 
+const int    INT_NULL           =    INT_MIN;
+const int64  INT64_NULL         =    INT64_MIN;
+
+const double DOUBLE_NULL        =    -1.0E+308;
+const double DOUBLE_NULL_LIM    =    -1.0E+307;
+
+class Nuller {
+public:
+	operator int() const                { return INT_NULL; }
+	operator int64() const              { return INT64_NULL; }
+	operator double() const             { return DOUBLE_NULL; }
+	operator bool() const               { return false; }
+	operator cdouble() const            { return cdouble(DOUBLE_NULL, DOUBLE_NULL); }
+
+	Nuller() {}
+};
+
+#ifdef flagSO
+static const Nuller Null;
+#else
+extern const Nuller Null;
+#endif
+
+template <class T> void SetNull(T& x) { x = Null; }
+template<> inline void SetNull(cdouble& x) { x = Null.operator cdouble(); }
+
+template <class T> bool IsNull(const T& x) { return x.IsNullInstance(); }
+
+template<> inline bool  IsNull(const int& i)     { return i == INT_NULL; }
+template<> inline bool  IsNull(const int64& i)   { return i == INT64_NULL; }
+template<> inline bool  IsNull(const double& r)  { return r < DOUBLE_NULL_LIM; }
+template<> inline bool  IsNull(const bool& r  )  { return false; }
+template<> inline bool  IsNull(const cdouble& r) { return r.real() < DOUBLE_NULL_LIM || r.imag() < DOUBLE_NULL_LIM; }
+
 #if defined(flagMT)
 	#if defined(PLATFORM_WIN32) && defined(COMPILER_GCC)
 		#define flagUSEMALLOC //MINGW does not support
diff --git a/uppsrc/Core/Stream.cpp b/uppsrc/Core/Stream.cpp
index d2eddd0..95bb29d 100644
--- a/uppsrc/Core/Stream.cpp
+++ b/uppsrc/Core/Stream.cpp
@@ -670,6 +670,13 @@ Stream& Stream::operator%(uint64& d)
 	return *this;
 }
 
+Stream& Stream::operator%(cdouble& d) {
+	double r,i;
+	if(IsStoring()) { r = d.real(); i = d.imag(); }
+	(*this) % r % i;
+	if(IsLoading()) { d = cdouble(r,i); }
+	return *this;
+}
 
 Stream& Stream::operator%(String& s) {
 	if(IsError()) return *this;
diff --git a/uppsrc/Core/Stream.h b/uppsrc/Core/Stream.h
index 11b31d2..e1f41e9 100644
--- a/uppsrc/Core/Stream.h
+++ b/uppsrc/Core/Stream.h
@@ -204,6 +204,7 @@ public:
 	Stream&   operator%(double& d);
 	Stream&   operator%(int64& d);
 	Stream&   operator%(uint64& d);
+	Stream&   operator%(cdouble& d);
 
 	Stream&   operator%(String& s);
 	Stream&   operator/(String& s);
diff --git a/uppsrc/Core/String.h b/uppsrc/Core/String.h
index ab03d05..c3edd90 100644
--- a/uppsrc/Core/String.h
+++ b/uppsrc/Core/String.h
@@ -390,8 +390,6 @@ public:
 
 inline bool  IsEmpty(const String& s)      { return s.IsEmpty(); }
 
-template <class T> bool IsNull(const T& x) { return x.IsNullInstance(); }
-
 String FormatPtr(const void *p);
 
 template <class T>
@@ -781,6 +779,7 @@ template<> inline String AsString(const char& a)            { return String(a, 1
 template<> inline String AsString(const signed char& a)     { return String(a, 1); }
 template<> inline String AsString(const unsigned char& a)   { return String(a, 1); }
 template<> inline String AsString(const bool& a)            { return a ? "true" : "false"; }
+template<> inline String AsString(const cdouble& x)         { return String().Cat() << "C(" << x.real() << "," << x.imag() << ")"; }
 
 unsigned ctoi(int c);
 
diff --git a/uppsrc/Core/Topt.h b/uppsrc/Core/Topt.h
index eda7cda..da3c17c 100644
--- a/uppsrc/Core/Topt.h
+++ b/uppsrc/Core/Topt.h
@@ -391,6 +391,7 @@ template<> inline unsigned GetHashValue(const wchar_t& a)        { return (const
 
 template<> inline unsigned GetHashValue(const int64& a)          { return CombineHash((unsigned)a, (unsigned)(a >> 32)); }
 template<> inline unsigned GetHashValue(const uint64& a)         { return GetHashValue((int64)a); }
+template<> inline unsigned GetHashValue(const cdouble& x)       { return CombineHash(x.real(), x.imag()); }
 
 unsigned GetHashValue0(const double& a);
 
diff --git a/uppsrc/Core/Uuid.h b/uppsrc/Core/Uuid.h
index b61d7d4..1efb085 100644
--- a/uppsrc/Core/Uuid.h
+++ b/uppsrc/Core/Uuid.h
@@ -2,7 +2,7 @@ struct Uuid : AssignValueTypeNo<Uuid, 50, Moveable<Uuid> > {
 	dword a, b, c, d;
 
 	void Serialize(Stream& s);
-	bool IsNull() const           { return a == 0 && b == 0 && c == 0 && d == 0; }
+	bool IsNullInstance() const   { return a == 0 && b == 0 && c == 0 && d == 0; }
 	void SetNull()                { a = b = c = d = 0; }
 
 	operator Value() const        { return RichValue<Uuid>(*this); }
@@ -32,9 +32,6 @@ inline bool  operator!=(const Uuid& u, const Uuid& w) {
 }
 
 template<>
-inline bool IsNull(const Uuid& id) { return id.IsNull(); }
-
-template<>
 inline String AsString(const Uuid& id) { return Format(id); }
 
 ValueGen& UuidValueGen();
diff --git a/uppsrc/Core/Value.cpp b/uppsrc/Core/Value.cpp
index 314d658..2226afb 100644
--- a/uppsrc/Core/Value.cpp
+++ b/uppsrc/Core/Value.cpp
@@ -58,6 +58,7 @@ Value::Value(double d)         { ptr = new RichValueRep<double>(d); }
 Value::Value(bool b)           { ptr = new RichValueRep<bool>(b); }
 Value::Value(Date d)           { ptr = new RichValueRep<Date>(d); }
 Value::Value(Time t)           { ptr = new RichValueRep<Time>(t); }
+Value::Value(cdouble c)        { ptr = new RichValueRep<cdouble>(c); }
 Value::Value(const Nuller&)    { ptr = new RichValueRep<int>(Null); }
 
 Value::operator String() const
@@ -121,6 +122,12 @@ Value::operator bool() const
 	return operator int();
 }
 
+Value::operator cdouble() const
+{
+	if(!Is<cdouble>()) return Null;
+	return RichValue<cdouble>::Extract(*this);
+}
+
 VectorMap<dword, Value::Void *(*)(Stream& s)>& Value::Typemap()
 {
 	static VectorMap<dword, Value::Void *(*)(Stream& s)> x;
@@ -154,6 +161,7 @@ static void sRegisterStd()
 		RichValue<Time>::Register();
 		Value::Register(VALUEARRAY_V, ValueArrayDataCreate);
 		Value::Register(VALUEMAP_V, ValueMapDataCreate);
+		RichValue<cdouble>::Register();
 	};
 }
 
diff --git a/uppsrc/Core/Value.h b/uppsrc/Core/Value.h
index 969daeb..073d43a 100644
--- a/uppsrc/Core/Value.h
+++ b/uppsrc/Core/Value.h
@@ -37,32 +37,6 @@ public:
 	Id(const IdConst& cnst);
 };
 
-const int    INT_NULL           =    INT_MIN;
-const int64  INT64_NULL         =    INT64_MIN;
-
-const double DOUBLE_NULL        =    -1.0E+308;
-const double DOUBLE_NULL_LIM    =    -1.0E+307;
-
-class Nuller {
-public:
-	operator int() const                { return INT_NULL; }
-	operator int64() const              { return INT64_NULL; }
-	operator double() const             { return DOUBLE_NULL; }
-	operator bool() const               { return false; }
-
-	Nuller() {}
-};
-
-#ifdef flagSO
-static const Nuller Null;
-#else
-extern const Nuller Null;
-#endif
-
-template<> inline bool  IsNull(const int& i)     { return i == INT_NULL; }
-template<> inline bool  IsNull(const int64& i)   { return i == INT64_NULL; }
-template<> inline bool  IsNull(const double& r)  { return r < DOUBLE_NULL_LIM; }
-template<> inline bool  IsNull(const bool& r  )  { return false; }
 template<> inline bool  IsNull(const Date& d)    { return d.year == -32768; }
 template<> inline bool  IsNull(const Time& t)    { return t.year == -32768; }
 
@@ -77,6 +51,8 @@ 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); }
 
+inline const cdouble& Nvl(const cdouble& a, const cdouble& b)  { return IsNull(a) ? b : a; }
+
 const dword VOID_V    = 0;
 
 const dword INT_V     = 1;
@@ -98,6 +74,8 @@ const dword BOOL_V   = 11;
 
 const dword VALUEMAP_V   = 12;
 
+const dword COMPLEX_V   = 20;
+
 const dword UNKNOWN_V = (dword)0xffffffff;
 
 class Value : Moveable<Value> {
@@ -150,6 +128,7 @@ public:
 	operator int() const;
 	operator int64() const;
 	operator bool() const;
+	operator cdouble() const;
 
 	Value(const String& s);
 	Value(const WString& s);
@@ -160,6 +139,7 @@ public:
 	Value(bool b);
 	Value(Date d);
 	Value(Time t);
+	Value(cdouble c);
 	Value(const Nuller&);
 
 	bool operator==(const Value& v) const;
@@ -195,6 +175,7 @@ VALUE_COMPARE(Date)
 VALUE_COMPARE(Time)
 VALUE_COMPARE(String)
 VALUE_COMPARE(WString)
+//VALUE_COMPARE(cdouble)
 
 inline bool operator==(const Value& v, const char *x)   { return (String)v == x; }
 inline bool operator==(const char *x, const Value& v)   { return (String)v == x; }
@@ -282,6 +263,7 @@ template<> inline dword ValueTypeNo(const String*)  { return STRING_V; }
 template<> inline dword ValueTypeNo(const WString*) { return WSTRING_V; }
 template<> inline dword ValueTypeNo(const Date*)    { return DATE_V; }
 template<> inline dword ValueTypeNo(const Time*)    { return TIME_V; }
+template<> inline dword ValueTypeNo(const cdouble*) { return COMPLEX_V; }
 
 template <class T, dword type, class B = EmptyClass>
 class AssignValueTypeNo : public B {
@@ -484,7 +466,7 @@ protected:
 	static const T& GetNull() {
 		static T *q;
 		ONCELOCK {
-			static T x(Null);
+			static T x; SetNull(x);
 			q = &x;
 		}
 		return *q;
@@ -544,7 +526,7 @@ struct RichRef : public RawRef<T> {
 	virtual Value GetValue(const void *p)           { return RichValue<T>(*(T *) p); }
 	virtual bool  IsNull(const void *p)             { return UPP::IsNull(*(T *) p); }
 	virtual void  SetValue(void *p, const Value& v) { *(T *) p = T(v); }
-	virtual void  SetNull(void *p)                  { *(T *) p = T(Null); }
+	virtual void  SetNull(void *p)                  { UPP::SetNull(*(T *)p); }
 };
 
 class Ref : Moveable<Ref> {
@@ -758,3 +740,8 @@ public:
 	Value operator++()                           { return Get(); }
 	virtual ~ValueGen() {}
 };
+
+inline bool operator==(const Value& v, cdouble x)   { return RichValue<cdouble>::Extract(v) == x; }
+inline bool operator==(cdouble x, const Value& v)   { return RichValue<cdouble>::Extract(v) == x; }
+inline bool operator!=(const Value& v, cdouble x)   { return RichValue<cdouble>::Extract(v) != x; }
+inline bool operator!=(cdouble x, const Value& v)   { return RichValue<cdouble>::Extract(v) != x; }
diff --git a/uppsrc/Draw/Draw.h b/uppsrc/Draw/Draw.h
index 1382414..d4a65a0 100644
--- a/uppsrc/Draw/Draw.h
+++ b/uppsrc/Draw/Draw.h
@@ -175,11 +175,11 @@ public:
 	bool  operator!=(Font f) const  { return !operator==(f); }
 
 	dword GetHashValue() const      { return CombineHash(v.width, v.flags, v.height, v.face); }
-	bool  IsNull() const            { return v.face == 0xffff; }
-
+	bool  IsNullInstance() const    { return v.face == 0xffff; }
+	void  SetNull()                 { v.face = 0xffff; v.height = v.width = 0; v.flags = 0; }
 	Font()                          { v.height = v.width = 0; v.face = v.flags = 0; }
 	Font(int face, int height)      { v.face = face; v.height = height; v.flags = 0; v.width = 0; }
-	Font(const Nuller&)             { v.face = 0xffff; v.height = v.width = 0; v.flags = 0; }
+	Font(const Nuller&)             { SetNull(); }
 
 	operator Value() const          { return RichValue<Font>(*this); }
 	Font(const Value& q)            { *this = RichValue<Font>::Extract(q); }
@@ -188,6 +188,7 @@ public:
 	FontInfo Info() const;
 };
 
+
 //BW compatibility
 class FontInfo {
 	Font font;
@@ -226,12 +227,6 @@ struct ComposedGlyph {
 bool Compose(Font fnt, int chr, ComposedGlyph& cs);
 
 template<>
-inline bool IsNull(const Font& f)            { return f.IsNull(); }
-
-template<>
-inline unsigned GetHashValue(const Font& f)  { return f.GetHashValue(); }
-
-template<>
 String AsString(const Font& f);
 
 inline void SetStdFont(Font font)                   { Font::SetStdFont(font); }
@@ -375,6 +370,7 @@ public:
 	void    Clear()                             { size = Null; data.Clear(); cmd.Clear(); }
 	void    Serialize(Stream& s)                { s % cmd % data % size; }
 	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; }
 	unsigned GetHashValue() const               { return CombineHash(cmd, data); }
 	String  ToString() const                    { return "painting " + AsString(size); }
@@ -382,8 +378,8 @@ public:
 	operator Value() const                      { return RichValue<Painting>(*this); }
 	Painting(const Value& q)                    { *this = RichValue<Painting>::Extract(q); }
 
-	Painting()                                  { size = Null; }
-	Painting(const Nuller&)                     { size = Null; }
+	Painting()                                  { SetNull(); }
+	Painting(const Nuller&)                     { SetNull(); }
 };
 
 enum {
@@ -635,6 +631,8 @@ public:
 	void Serialize(Stream& s);
 
 	bool    IsNullInstance() const             { return data.IsEmpty(); }
+	void    SetNull()                          { size = Null; }
+
 	bool    operator==(const Drawing& b) const { return val == b.val && data == b.data && size == b.size; }
 	String  ToString() const                   { return "drawing " + AsString(size); }
 	unsigned GetHashValue() const              { return CombineHash(data, val); }
@@ -642,8 +640,8 @@ public:
 	operator Value() const         { return RichValue<Drawing>(*this); }
 	Drawing(const Value& src);
 
-	Drawing()                      { size = Null; }
-	Drawing(const Nuller&)         { size = Null; }
+	Drawing()                      { SetNull(); }
+	Drawing(const Nuller&)         { SetNull(); }
 };
 
 class DrawingDraw : public Draw {
diff --git a/uppsrc/Draw/Font.cpp b/uppsrc/Draw/Font.cpp
index dfc8fa4..93a128b 100644
--- a/uppsrc/Draw/Font.cpp
+++ b/uppsrc/Draw/Font.cpp
@@ -151,14 +151,14 @@ int Font::GetHeight() const
 }
 
 String Font::GetFaceName() const {
-	if(IsNull()) return String();
+	if(IsNullInstance()) return String();
 	if(GetFace() == 0)
 		return "STDFONT";
 	return GetFaceName(GetFace());
 }
 
 dword Font::GetFaceInfo() const {
-	if(IsNull()) return 0;
+	if(IsNullInstance()) return 0;
 	return GetFaceInfo(GetFace());
 }
 
@@ -204,7 +204,7 @@ void Font::Serialize(Stream& s) {
 		s % name;
 		if(s.IsLoading()) {
 			FaceName(name);
-			if(IsNull())
+			if(IsNullInstance())
 				Face(COURIER);
 		}
 	}