bazaar: adding: AutoScroller, CtrlFinder, CtrlProp(erties), Iter(ator) interface, LogPosCtrl, PointCtrl, PopUpC, RectCtrl, Styler, ValueCtrl, WithEnterAction

git-svn-id: svn://ultimatepp.org/upp/trunk@2942 f0d560ea-af0d-0410-9eb7-867de7ffcac7
2026-05-21 06:45:39 -06:00 · 2010-12-28 16:50:38 +00:00 · 2010-12-28 16:50:38 +00:00 · be38f2e534
commit be38f2e534
parent 0567486daa
116 changed files with 5591 additions and 0 deletions
--- a/bazaar/AutoScroller/AutoScroller.cpp
+++ b/bazaar/AutoScroller/AutoScroller.cpp
@ -0,0 +1,3 @@
+#include "AutoScroller.hpp"
+
+template class AutoScroller<ParentCtrl>;
--- a/bazaar/AutoScroller/AutoScroller.h
+++ b/bazaar/AutoScroller/AutoScroller.h
@ -0,0 +1,36 @@
+#ifndef _AutoScroller_AutoScroller_h_
+#define _AutoScroller_AutoScroller_h_
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+template<class C = ParentCtrl>
+class AutoScroller
+	: public ParentCtrl
+{
+public:
+	typedef AutoScroller CLASSNAME;
+	AutoScroller();
+	
+public:
+	virtual void Layout();
+	
+	void SetPaneSize(const Size & sz);
+	Size GetPaneSize() const { return pane.GetSize(); }
+
+	void EnableScroll(bool b = true);
+	void DisableScroll() { EnableScroll(false); }
+	bool IsEnabledScroll() const { return scroll.x.IsEnabled() || scroll.y.IsEnabled(); }
+
+	C pane;
+
+protected:
+	void OnScroll();
+
+private:	
+	ScrollBars scroll;
+};
+
+
+#endif
--- a/bazaar/AutoScroller/AutoScroller.hpp
+++ b/bazaar/AutoScroller/AutoScroller.hpp
@ -0,0 +1,56 @@
+#ifndef _AutoScroller_AutoScroller_hpp_
+#define _AutoScroller_AutoScroller_hpp_
+
+#include "AutoScroller.h"
+
+template<class C>
+AutoScroller<C>::AutoScroller()
+{
+	EnableScroll();
+	scroll.WhenScroll = THISBACK(OnScroll);
+	Add(pane.TopPos(0).LeftPos(0));
+	SetPaneSize(GetSize());
+}
+
+template<class C>
+void AutoScroller<C>::OnScroll()
+{
+	Point tl(-scroll.GetX(), -scroll.GetY());
+	Rect r = pane.GetRect();
+	Rect _r(tl, r.GetSize());
+	pane.SetRect(_r);
+}
+
+template<class C>
+void AutoScroller<C>::Layout()
+{
+	Size sz = GetSize();
+	if(sz != scroll.GetPage())
+		scroll.SetPage(sz);
+}
+
+template<class C>
+void AutoScroller<C>::SetPaneSize(const Size & sz)
+{
+	Ctrl::LogPos logp;
+	logp.x = ParentCtrl::PosLeft(0, sz.cx);
+	logp.y = ParentCtrl::PosTop(0, sz.cy);
+	pane.SetPos(logp);
+	scroll.SetTotal(sz);
+}
+
+template<class C>
+void AutoScroller<C>::EnableScroll(bool b)
+{
+	if(b)
+		AddFrame(scroll.AutoHide());
+	else
+		RemoveFrame(scroll);
+	scroll.x.Enable(b);
+	scroll.y.Enable(b);
+	return;
+	scroll.Show(b);
+	Layout();
+}
+
+#endif
--- a/bazaar/AutoScroller/AutoScroller.upp
+++ b/bazaar/AutoScroller/AutoScroller.upp
@ -0,0 +1,10 @@
+description "A templateable autoscrolling control container\377";
+
+uses
+	CtrlLib;
+
+file
+	AutoScroller.h,
+	AutoScroller.hpp,
+	AutoScroller.cpp;
+
--- a/bazaar/AutoScroller/init
+++ b/bazaar/AutoScroller/init
@ -0,0 +1,4 @@
+#ifndef _AutoScroller_icpp_init_stub
+#define _AutoScroller_icpp_init_stub
+#include "CtrlLib/init"
+#endif
--- a/bazaar/AutoScrollerTest/AutoScrollerTest.h
+++ b/bazaar/AutoScrollerTest/AutoScrollerTest.h
@ -0,0 +1,31 @@
+#ifndef _AutoScrollerTest_AutoScrollerTest_h
+#define _AutoScrollerTest_AutoScrollerTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define LAYOUTFILE <AutoScrollerTest/AutoScrollerTest.lay>
+#include <CtrlCore/lay.h>
+
+#define IMAGEFILE <AutoScrollerTest/AutoScrollerTest.iml>
+#include <Draw/iml_header.h>
+
+//if use only ParentCtrl as pane
+//#include <AutoScroller/AutoScroller.h>
+//if use custom panes
+#include <AutoScroller/AutoScroller.hpp>
+
+class AutoScrollerTest : public WithAutoScrollerTestLayout<TopWindow> {
+public:
+	typedef AutoScrollerTest CLASSNAME;
+	AutoScrollerTest();
+	
+	void Toggle();
+	
+	AutoScroller<WithTestLay<ParentCtrl> > sc;
+	//WithTestLay<ParentCtrl> view;
+};
+
+#endif
+
--- a/bazaar/AutoScrollerTest/AutoScrollerTest.iml
+++ b/bazaar/AutoScrollerTest/AutoScrollerTest.iml
@ -0,0 +1,6 @@
+PREMULTIPLIED
+IMAGE_ID(blaa)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,99,16,96,16,96,24,5,163,96,20,140,2,0,133,109,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(32, 1)
--- a/bazaar/AutoScrollerTest/AutoScrollerTest.lay
+++ b/bazaar/AutoScrollerTest/AutoScrollerTest.lay
@ -0,0 +1,12 @@
+LAYOUT(AutoScrollerTestLayout, 200, 100)
+END_LAYOUT
+
+LAYOUT(TestLay, 640, 440)
+	ITEM(DocEdit, doc0, LeftPosZ(12, 68).TopPosZ(12, 44))
+	ITEM(DocEdit, doc1, LeftPosZ(12, 164).BottomPosZ(12, 176))
+	ITEM(DocEdit, doc3, RightPosZ(16, 176).TopPosZ(16, 92))
+	ITEM(DocEdit, doc2, RightPosZ(12, 176).BottomPosZ(12, 92))
+	ITEM(ProgressIndicator, dv___4, LeftPosZ(112, 440).TopPosZ(156, 24))
+	ITEM(Button, tg, SetLabel(t_("Toggle")).LeftPosZ(84, 56).TopPosZ(40, 15))
+END_LAYOUT
+
--- a/bazaar/AutoScrollerTest/AutoScrollerTest.upp
+++ b/bazaar/AutoScrollerTest/AutoScrollerTest.upp
@ -0,0 +1,15 @@
+description "how to extend a control with automatic scroll bars\377";
+
+uses
+	CtrlLib,
+	AutoScroller;
+
+file
+	AutoScrollerTest.h,
+	main.cpp,
+	AutoScrollerTest.lay,
+	AutoScrollerTest.iml;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/AutoScrollerTest/init
+++ b/bazaar/AutoScrollerTest/init
@ -0,0 +1,5 @@
+#ifndef _ScrollBarEx_icpp_init_stub
+#define _ScrollBarEx_icpp_init_stub
+#include "CtrlLib/init"
+#include "AutoScroller/init"
+#endif
--- a/bazaar/AutoScrollerTest/main.cpp
+++ b/bazaar/AutoScrollerTest/main.cpp
@ -0,0 +1,41 @@
+#include "AutoScrollerTest.h"
+
+#define IMAGEFILE <AutoScrollerTest/AutoScrollerTest.iml>
+#include <Draw/iml_source.h>
+
+void AutoScrollerTest::Toggle()
+{
+	sc.EnableScroll(!sc.IsEnabledScroll());
+}
+
+AutoScrollerTest::AutoScrollerTest()
+{
+	CtrlLayout(*this, "Window title");
+	Sizeable().Zoomable();
+
+	CtrlLayout(sc.pane);
+
+	//determine the total size of the scrolling pane
+	//or updaten it, i.e. after CtrlLayout
+	sc.SetPaneSize(sc.pane.GetSize());
+
+	//add content to the scrolling pane, if not CtrlLayouted
+	//sc.pane.Add(view);
+
+	//add the AutoScroller itself to application
+	Add(sc.SizePos());
+
+	//do other setup stuff
+	sc.pane.tg <<= THISBACK(Toggle);
+	
+	sc.pane.doc0 <<= "doc0";
+	sc.pane.doc1 <<= "doc1";
+	sc.pane.doc2 <<= "doc2";
+	sc.pane.doc3 <<= "doc3";
+}
+
+GUI_APP_MAIN
+{
+	AutoScrollerTest().Run();
+}
+
--- a/bazaar/CtrlFinder/CtrlFinder.cpp
+++ b/bazaar/CtrlFinder/CtrlFinder.cpp
@ -0,0 +1,24 @@
+#include "CtrlFinder.h"
+
+Ctrl* GetCtrl(Ctrl* parent, Point p, dword keyflags)
+{
+	Ctrl* c = parent->GetFirstChild();
+	while(c)
+	{
+		Rect r = c->GetRect();
+		if(r.Contains(p)) return c;
+		c = c->GetNext();	
+	}
+	return NULL;
+}
+
+void CtrlFinder::OnCtrlLeft(Point p, dword keyflags)
+{
+	Ctrl* c = GetCtrlFromParent(p, keyflags);
+	if(c) WhenLeftDown(*c, p, keyflags);
+}
+void CtrlFinder::OnCtrlRight(Point p, dword keyflags)
+{
+	Ctrl* c = GetCtrlFromParent(p, keyflags);
+	if(c) WhenRightDown(*c, p, keyflags);
+}
--- a/bazaar/CtrlFinder/CtrlFinder.h
+++ b/bazaar/CtrlFinder/CtrlFinder.h
@ -0,0 +1,62 @@
+#ifndef _CtrlFinder_CtrlFinder_h
+#define _CtrlFinder_CtrlFinder_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+class MouseHookCtrl : public ParentCtrl
+{
+public:
+	typedef MouseHookCtrl CLASSNAME;
+	MouseHookCtrl() : minsize(Null) { Update(); }
+
+	void    SetMinSize(Size sz) { minsize = sz; }
+	virtual Rect GetVoidRect()const { return GetSize(); }
+	virtual Size GetStdSize() const { return GetMinSize(); }
+	virtual Size GetMinSize() const { return IsNull(minsize) ? Ctrl::GetMinSize() : minsize; }
+
+	virtual void LeftDown(Point p, dword keyflags) { WhenLeftDown(p,keyflags); }
+	virtual void RightDown(Point p, dword keyflags) { WhenRightDown(p,keyflags); }
+	virtual void LeftUp(Point p, dword keyflags) { WhenLeftUp(p,keyflags); }
+	virtual void RightUp(Point p, dword keyflags) { WhenRightUp(p,keyflags); }
+	virtual void MouseMove(Point p, dword keyflags) { WhenMouseMove(p,keyflags); }
+	virtual void LeftRepeat(Point p, dword keyflags) { WhenLeftRepeat(p,keyflags); }
+	virtual void RightRepeat(Point p, dword keyflags) { WhenRightRepeat(p,keyflags); }
+
+	virtual void Updated() { IgnoreMouse(!IsEnabled()); }
+
+	Callback2<Point, dword> WhenLeftDown;
+	Callback2<Point, dword> WhenRightDown;
+	Callback2<Point, dword> WhenLeftUp;
+	Callback2<Point, dword> WhenRightUp;
+	Callback2<Point, dword> WhenMouseMove;
+	Callback2<Point, dword> WhenLeftRepeat;
+	Callback2<Point, dword> WhenRightRepeat;
+
+protected:
+	Size minsize;
+};
+
+Ctrl* GetCtrl(Ctrl* parent, Point p, dword keyflags);
+
+class CtrlFinder : public MouseHookCtrl
+{
+public:
+	typedef CtrlFinder CLASSNAME;
+	typedef MouseHookCtrl R;
+	CtrlFinder() { R::WhenLeftDown = THISBACK(OnCtrlLeft); R::WhenRightDown = THISBACK(OnCtrlRight);}
+
+	Ctrl* GetCtrl(Point p, dword keyflags) { return ::GetCtrl(this, p, keyflags); }
+	Ctrl* GetCtrlFromParent(Point p, dword keyflags) { return ::GetCtrl(GetParent(), p, keyflags); }
+	
+	Callback3<Ctrl&, Point, dword> WhenLeftDown;
+	Callback3<Ctrl&, Point, dword> WhenRightDown;
+
+protected:
+	void OnCtrlLeft(Point p, dword keyflags);
+	void OnCtrlRight(Point p, dword keyflags);
+};
+
+#endif
+
--- a/bazaar/CtrlFinder/CtrlFinder.upp
+++ b/bazaar/CtrlFinder/CtrlFinder.upp
@ -0,0 +1,9 @@
+description "Find a Ctrl using a transparent Hook Ctrl, see CtrlPropTest\377";
+
+uses
+	CtrlLib;
+
+file
+	CtrlFinder.h,
+	CtrlFinder.cpp;
+
--- a/bazaar/CtrlFinder/init
+++ b/bazaar/CtrlFinder/init
@ -0,0 +1,4 @@
+#ifndef _CtrlFinder_icpp_init_stub
+#define _CtrlFinder_icpp_init_stub
+#include "CtrlLib/init"
+#endif
--- a/bazaar/CtrlProp/Ctrl.cpp
+++ b/bazaar/CtrlProp/Ctrl.cpp
@ -0,0 +1,46 @@
+#include "CtrlProp.h"
+#include <CtrlLib/CtrlLib.h>
+
+bool PropSetData(Ctrl& o, const Value& v) { o.SetData(v); return true; }
+bool PropGetData(const Ctrl& o, Value& v) { v = o.GetData(); return true; }
+bool PropEnable(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Enable(v); return true; }
+bool PropIsEnabled(const Ctrl& o, Value& v) { v = o.IsEnabled(); return true; }
+bool PropShow(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Show(v); return true; }
+bool PropIsVisible(const Ctrl& o, Value& v) { v = o.IsVisible(); return true; }
+bool PropEditable(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.SetEditable(v); return true; }
+bool PropIsEditable(const Ctrl& o, Value& v) { v = o.IsEditable(); return true; }
+bool PropFocus(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; bool b = v; if(b) o.SetFocus(); else if(o.GetParent()) o.GetParent()->SetFocus(); return true; }
+bool PropHasFocus(const Ctrl& o, Value& v) { v = o.HasFocus(); return true; }
+bool PropModify(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; bool b = v; if(b) o.SetModify(); else o.ResetModify(); return true; }
+bool PropIsModified(const Ctrl& o, Value& v) { v = o.IsModified(); return true; }
+bool PropSetTip(Ctrl& o, const Value& v) { o.Tip(AsString(v)); return true; }
+bool PropGetTip(const Ctrl& o, Value& v) { v = o.GetTip(); return true; }
+bool PropWantFocus(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.WantFocus(v); return true; }
+bool PropIsWantFocus(const Ctrl& o, Value& v) { v = o.IsWantFocus(); return true; }
+bool PropInitFocus(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.InitFocus(v); return true; }
+bool PropIsInitFocus(const Ctrl& o, Value& v) { v = o.IsInitFocus(); return true; }
+bool PropBackPaint(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.BackPaint(((bool(v))?(Ctrl::FULLBACKPAINT):(Ctrl::NOBACKPAINT))); return true; }
+bool PropIsBackPaint(const Ctrl& o, Value& v) { v = bool(o.GetBackPaint()!=Ctrl::NOBACKPAINT); return true; }
+bool PropTransparent(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Transparent(v); return true; }
+bool PropIsTransparent(const Ctrl& o, Value& v) { v = o.IsTransparent(); return true; }
+
+bool PropRefresh(Ctrl& o, const Value& v) { o.Refresh(); return true; }
+
+bool PropSetLogPos(Ctrl& o, const Value& v) { if(!v.Is<Ctrl::LogPos>()) return false; o.SetPos(RawValue<Ctrl::LogPos>::Extract(v)); return true; }
+bool PropGetLogPos(const Ctrl& o, Value& v) { v = RawToValue(o.GetPos()); return true; }
+
+CTRL_PROPERTIES(Ctrl, RecurseDone)
+PROPERTY("data", PropSetData, PropGetData)
+PROPERTY("enable", PropEnable, PropIsEnabled)
+PROPERTY("show", PropShow, PropIsVisible)
+PROPERTY("editable", PropEditable, PropIsEditable)
+PROPERTY("logpos", PropSetLogPos, PropGetLogPos)
+PROPERTY("focus", PropFocus, PropHasFocus)
+PROPERTY("modify", PropModify, PropIsModified)
+PROPERTY("tip", PropSetTip, PropGetTip)
+PROPERTY("wantfocus", PropWantFocus, PropIsWantFocus)
+PROPERTY("initFocus", PropInitFocus, PropIsInitFocus)
+PROPERTY("backpaint", PropBackPaint, PropIsBackPaint)
+PROPERTY("transparent", PropTransparent, PropIsTransparent)
+//PROPERTY_SET("refresh", PropRefresh)
+END_CTRL_PROPERTIES
--- a/bazaar/CtrlProp/CtrlProp.cpp
+++ b/bazaar/CtrlProp/CtrlProp.cpp
@ -0,0 +1,29 @@
+#include "CtrlProp.h"
+
+void AddToValueArray(Value& v, const Vector<String>& k)
+{
+	if(!v.Is<ValueArray>()) 
+	{
+		v = ValueArray(Vector<Value>());
+	}
+	ValueArray va = v;
+	Vector<Value>& vv = const_cast<Vector<Value>&>(va.Get());
+	for(int i = 0; i < k.GetCount(); i++)
+		vv << k[i];
+}
+
+bool GetSetPropRecurseDone(Ctrl& c, const String& p, Value& v, int f) { return false; }
+
+VectorMap<String, ParamHandler>& pmap()
+{
+	static VectorMap<String, ParamHandler> _;
+	return _;
+}
+
+bool Property(Ctrl& c, const String& p, Value& v, int f)
+{
+	int i = pmap().Find(String(typeid(c).name()));
+	if(i<0) return false;
+	return pmap()[i](c,p,v,f);
+}
+
--- a/bazaar/CtrlProp/CtrlProp.h
+++ b/bazaar/CtrlProp/CtrlProp.h
@ -0,0 +1,170 @@
+#ifndef _CtrlProp_CtrlProp_h
+#define _CtrlProp_CtrlProp_h
+
+#include <CtrlCore/CtrlCore.h>
+using namespace Upp;
+
+enum
+{
+	PROPGET = 0,
+	PROPSET = 1,
+};
+
+template<class C> struct GetTyper{
+	typedef bool (*H)(const C&, Value&);
+	typedef Gate2<const C&, Value&> Handler;
+	static ArrayMap<String, Handler>& map() { static ArrayMap<String, Handler> _; return _; }
+};
+template<class C> struct SetTyper{
+	typedef bool (*H)(C&, const Value&);
+	typedef Gate2<C&, const Value&> Handler;
+	static ArrayMap<String, Handler>& map() { static ArrayMap<String, Handler> _; return _; }
+};
+
+typedef Gate4<Ctrl&, const String&, Value&, int> ParamHandler;
+VectorMap<String, ParamHandler>& pmap();
+#define REGISTERPROPS(CTRL) pmap().GetAdd(String(typeid(CTRL).name())) = callback(&GetSetProp##CTRL)
+
+void AddToValueArray(Value& v, const Vector<String>& k);
+bool GetSetPropRecurseDone(Ctrl& c, const String& p, Value& v, int f);
+
+#define DEC_CTRL_PROPERTIES(CTRL) \
+bool GetSetProp##CTRL(Ctrl& c, const String& p, Value& v, int f) \
+
+
+#define CTRL_PROPERTIES(CTRL, BASE) \
+DEC_CTRL_PROPERTIES(CTRL); \
+DEC_CTRL_PROPERTIES(BASE); \
+INITBLOCK { REGISTERPROPS(CTRL); } \
+DEC_CTRL_PROPERTIES(CTRL) \
+{ \
+	typedef CTRL _CTRL_; \
+	if(0) { __base: return GetSetProp##BASE(c,p,v,f); } \
+	ONCELOCK { \
+
+
+#define END_CTRL_PROPERTIES \
+	} \
+	_CTRL_* pc = dynamic_cast<_CTRL_*>(&c); \
+	if(!pc) return false; \
+	_CTRL_& o = *pc; \
+ \
+	ArrayMap<String, SetTyper<_CTRL_>::Handler>& s = SetTyper<_CTRL_>::map(); \
+	ArrayMap<String, GetTyper<_CTRL_>::Handler>& g = GetTyper<_CTRL_>::map(); \
+	if(f&PROPSET) \
+	{ \
+		int i = s.Find(p); if(i>=0) return s[i](o, v); \
+	} \
+	else \
+	{ \
+		int i = g.Find(p); if(i>=0) return g[i](o, v); \
+		if(p == "listset") AddToValueArray(v, s.GetKeys()); \
+		else if(p == "listget") AddToValueArray(v, g.GetKeys()); \
+	} \
+	goto __base; \
+} \
+
+
+#define EXT_PROPERTY_SET(CTRL, name, fset) \
+		SetTyper<CTRL>::map().GetAdd(name) = callback((SetTyper<CTRL>::H)&fset); \
+
+
+#define EXT_PROPERTY_GET(CTRL, name, fget) \
+		GetTyper<CTRL>::map().GetAdd(name) = callback((GetTyper<CTRL>::H)&fget); \
+
+
+#define EXT_PROPERTY(CTRL, name, fset, fget) \
+	EXT_PROPERTY_SET(CTRL, name, fset) \
+	EXT_PROPERTY_GET(CTRL, name, fget) \
+
+
+#define PROPERTY_SET(name, fset) \
+	EXT_PROPERTY_SET(_CTRL_, name, fset) \
+
+
+#define PROPERTY_GET(name, fset) \
+	EXT_PROPERTY_GET(_CTRL_, name, fset) \
+
+
+#define PROPERTY(name, fset, fget) \
+	EXT_PROPERTY_SET(_CTRL_, name, fset) \
+	EXT_PROPERTY_GET(_CTRL_, name, fget) \
+
+
+
+#define EXT_UNPROPERTY_SET(CTRL, name) \
+		SetTyper<CTRL>::map().RemoveKey(name); \
+
+#define EXT_UNPROPERTY_GET(CTRL, name) \
+		GetTyper<CTRL>::map().RemoveKey(name); \
+
+#define EXT_UNPROPERTY(CTRL, name) \
+	EXT_UNPROPERTY_SET(CTRL, name) \
+	EXT_UNPROPERTY_GET(CTRL, name) \
+
+
+#define UNPROPERTY_SET(name, fset) \
+	EXT_UNPROPERTY_SET(_CTRL_, name, fset) \
+
+
+#define UNPROPERTY_GET(name, fset) \
+	EXT_UNPROPERTY_GET(_CTRL_, name, fset) \
+
+
+#define UNPROPERTY(name, fset, fget) \
+	EXT_UNPROPERTY_SET(_CTRL_, name, fset) \
+	EXT_UNPROPERTY_GET(_CTRL_, name, fget) \
+
+
+bool Property(Ctrl& c, const String& p, Value& v, int f);
+inline bool SetProperty(Ctrl& c, const String& p, const Value& v) { return Property(c,p,const_cast<Value&>(v),PROPSET); }
+inline bool GetProperty(const Ctrl& c, const String& p, Value& v) { return Property(const_cast<Ctrl&>(c),p,v,PROPGET); }
+
+//helpers for editing
+
+#include <CtrlLib/CtrlLib.h>
+using namespace Upp;
+
+#include <LogPosCtrl/LogPosCtrl.h>
+#include <ValueCtrl/ValueCtrl.h>
+
+VectorMap<String, int> BidirProps(Ctrl& c);
+
+#define LAYOUTFILE <CtrlProp/CtrlPropEdit.lay>
+#include <CtrlCore/lay.h>
+
+class PropList : public WithPropListLay<PopUpC>
+{
+public:
+	typedef PropList CLASSNAME;
+	PropList();
+
+	void Evaluate(Ctrl& e);
+	void PopUp(Ctrl* owner, Ctrl& e) { Evaluate(e); PopUpC::PopUp(owner); }
+};
+
+class PropEdit : public WithPropEditLay<PopUpC>
+{
+public:
+	typedef PropEdit CLASSNAME;
+	PropEdit();
+
+	virtual void Deactivate() {} //let other popups open
+
+	void Evaluate(Ctrl& e);
+	void PopUp(Ctrl* owner, Ctrl& e) { Evaluate(e); PopUpC::PopUp(owner); }
+
+	virtual void Rejector();
+	virtual void Acceptor();
+
+public:
+	void OnUpdateRow();
+
+	Ctrl* pe;
+	ArrayMap<String, Tuple2<bool, Value> > vsav;
+};
+
+
+
+#endif
+
--- a/bazaar/CtrlProp/CtrlProp.hpp
+++ b/bazaar/CtrlProp/CtrlProp.hpp
@ -0,0 +1,10 @@
+#ifndef _CtrlProp_CtrlProp_hpp
+#define _CtrlProp_CtrlProp_hpp
+
+#include "CtrlProp.h"
+
+//type specific maps for the handlers
+template<class T> ArrayMap<String, Gate2<T&, const Value&> >& wpmap() { static ArrayMap<String, Gate2<T&, const Value&> > _; return _; }
+template<class T> ArrayMap<String, Callback2<const T&, Value&> >& rpmap() { static ArrayMap<String, Callback2<const T&, Value&> > _; return _; }
+
+#endif
--- a/bazaar/CtrlProp/CtrlProp.upp
+++ b/bazaar/CtrlProp/CtrlProp.upp
@ -0,0 +1,20 @@
+description "Ctrl properties editing in a common interface, see CtrlPropTest\377";
+
+uses
+	CtrlLib,
+	LogPosCtrl,
+	ValueCtrl;
+
+file
+	CtrlProp.h,
+	CtrlProp.cpp,
+	CtrlPropEdit.cpp,
+	CtrlPropEdit.lay,
+	Props readonly separator,
+	Ctrl.cpp,
+	PushCtrl.cpp,
+	EditCtrl.cpp,
+	TextEdit.cpp,
+	StaticCtrl.cpp,
+	SliderCtrl.cpp;
+
--- a/bazaar/CtrlProp/CtrlPropEdit.cpp
+++ b/bazaar/CtrlProp/CtrlPropEdit.cpp
@ -0,0 +1,192 @@
+#include "CtrlProp.h"
+
+VectorMap<String, int> BidirProps(Ctrl& c)
+{
+	VectorMap<String, int> is;
+	Value vs;
+	GetProperty(c, "listset", vs);
+	if(!vs.Is<ValueArray>())
+		return is;
+	ValueArray vas = vs;
+
+	for(int i = 0; i < vas.GetCount(); i++)
+	{
+		int& m = is.GetAdd(vas.Get(i), 0);
+		m |= 1;
+	}
+
+	Value vg;
+	GetProperty(c, "listget", vg);
+	if(!vg.Is<ValueArray>())
+		return is;
+	ValueArray vag = vg;
+
+	for(int i = 0; i < vag.GetCount(); i++)
+	{
+		int& m = is.GetAdd(vag.Get(i), 0);
+		m |= 2;
+	}
+
+	return is;
+}
+
+PropList::PropList()
+{
+	CtrlLayout(*this);
+	ok <<= THISBACK(Acceptor);
+	cancel <<= THISBACK(Rejector);
+}
+
+void PropList::Evaluate(Ctrl& e)
+{
+	Value v;
+	bool b;
+	String t;
+
+	b = GetProperty(e, "listset", v);
+	ValueArray vs = v;
+	t << "Set Properties: (" << vs.GetCount() << ")\n" << v;
+	gl.SetData(t);
+
+	v = Value();
+	b = GetProperty(e, "listget", v);
+	t.Clear();
+	ValueArray vg = v;
+	t << "Get Properties: (" << vg.GetCount() << ")\n";
+	{
+		for(int i = 0; i < vg.GetCount(); i++)
+		{
+			String s = vg.Get(i);
+			Value v;
+			t << "{" << s << "} = ";
+			b = GetProperty(e, s, v);
+			if(b) t << v;
+			else t << "##ERR##";
+			t << "\n";
+		}
+	}
+	sl.SetData(t);
+}
+
+PropEdit::PropEdit()
+{
+	CtrlLayout(*this);
+	ok <<= THISBACK(Acceptor);
+	cancel <<= THISBACK(Rejector);
+
+	ac.AddColumn("Property");
+	ac.AddColumn("Value");
+	//ac.WhenUpdateRow = THISBACK(OnUpdateRow);
+}
+
+void PropEdit::Evaluate(Ctrl& e)
+{
+	pe = &e;
+	ac.Clear();
+	vsav.Clear();
+
+	VectorMap<String, int> is = BidirProps(e);
+	
+	int k = 0;
+	for(int i = 0; i < is.GetCount(); i++)
+	{
+		String tag = is.GetKey(i);
+		int& m = is[i];
+
+		Value v;
+		if(m&2)
+		{
+			if(!GetProperty(e, tag, v))
+				continue;
+		}
+		ac.Set(k, 0, tag);
+		ac.Set(k, 1, v); //forwarded to controls
+	
+		switch(m)
+		{
+			case 3: //bidir
+			{
+				Tuple2<bool, Value>& tv = vsav.Add(tag);
+				tv.a = false;
+				tv.b = v;
+			
+				Ctrl* pc;
+				if(!v.IsNull())
+				{
+					pc = DefaultValueEditor(v);
+					{
+						LogPosCtrl* ple = dynamic_cast<LogPosCtrl*>(pc);
+						if(ple)
+							ple->Set(e);
+					}
+				}
+				else pc = new ValueCtrl();
+				pc->WhenAction = THISBACK(OnUpdateRow);
+
+				ac.SetCtrl(k, 1, pc); //owned
+				++k;
+			}
+				break;
+			case 2: //getter only
+			{
+				StaticText* pc = new StaticText();
+				pc->SetText(AsString(v));
+
+				ac.SetCtrl(k, 1, pc); //owned
+				++k;
+			}
+				break;
+			case 1: //setter only
+			{
+				//FIXME needs to know which type
+				//meanwhile, we let user choose
+				ValueCtrl* pc = new ValueCtrl();
+				pc->WhenAction = THISBACK(OnUpdateRow);
+
+				ac.SetCtrl(k, 1, pc); //owned
+				++k;
+			}
+				break;
+			default:
+				break;
+		}
+	}
+}
+
+void PropEdit::OnUpdateRow()
+{
+	if(!pe) return;
+	if(!ac.IsCursor()) return; //FIXME Option Focus issue 
+	SetProperty(*pe, ac.Get(0), ac.Get(1));
+	vsav.GetAdd(ac.Get(0)).a = true; //dirty
+	pe->UpdateRefresh();
+}
+
+void PropEdit::Rejector()
+{
+	if(pe)
+	{
+		for(int i = 0; i < vsav.GetCount(); i++)
+			if(vsav[i].a)
+				SetProperty(*pe, vsav.GetKey(i), vsav[i].b);
+	}
+	pe = NULL;
+	ac.Clear();
+	vsav.Clear();
+	
+	PopUpC::Rejector();
+}
+
+void PropEdit::Acceptor()
+{
+	if(0 && pe) //FIXME when direct editing works, we can spare this out
+	{
+		for(int i = 0; i < ac.GetCount(); i++)
+			SetProperty(*pe, ac.Get(i, 0), ac.Get(i, 1));
+	}
+	pe = NULL;
+	ac.Clear();
+	vsav.Clear();
+	
+	PopUpC::Acceptor();
+}
--- a/bazaar/CtrlProp/CtrlPropEdit.lay
+++ b/bazaar/CtrlProp/CtrlPropEdit.lay
@ -0,0 +1,18 @@
+LAYOUT(PropListLay, 400, 200)
+	ITEM(DocEdit, gl, WantFocus(false).SetEditable(false).LeftPosZ(0, 168).VSizePosZ(0, 20))
+	ITEM(DocEdit, sl, WantFocus(false).SetEditable(false).HSizePosZ(168, 0).VSizePosZ(0, 20))
+	ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20))
+	ITEM(Button, ok, SetLabel(t_("Ok")).RightPosZ(56, 56).BottomPosZ(0, 20))
+END_LAYOUT
+
+LAYOUT(PropEditLay, 400, 200)
+	ITEM(ArrayCtrl, ac, HSizePosZ(0, 0).VSizePosZ(0, 20))
+	ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20))
+	ITEM(Button, ok, SetLabel(t_("Ok")).RightPosZ(56, 56).BottomPosZ(0, 20))
+END_LAYOUT
+
+LAYOUT(ValuePopUp, 400, 200)
+	ITEM(Button, ok, SetLabel(t_("OK")).RightPosZ(56, 56).BottomPosZ(0, 20))
+	ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20))
+END_LAYOUT
+
--- a/bazaar/CtrlProp/EditCtrl.cpp
+++ b/bazaar/CtrlProp/EditCtrl.cpp
@ -0,0 +1,191 @@
+#include "CtrlProp.h"
+#include <CtrlLib/CtrlLib.h>
+
+//EditField
+
+bool PropSetPassword(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.Password(v); return true; }
+bool PropGetPassword(const EditField& o, Value& v) { v = o.IsPassword(); return true; }
+bool PropSetAutoFormat(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.AutoFormat(v); return true; }
+bool PropGetAutoFormat(const EditField& o, Value& v) { v = o.IsAutoFormat(); return true; }
+bool PropSetClickSelect(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.ClickSelect(v); return true; }
+bool PropGetClickSelect(const EditField& o, Value& v) { v = o.IsClickSelect(); return true; }
+bool PropSetInitCaps(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.InitCaps(v); return true; }
+bool PropGetInitCaps(const EditField& o, Value& v) { v = o.IsInitCaps(); return true; }
+bool PropSetMaxChars(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.MaxChars(v); return true; }
+bool PropGetMaxChars(const EditField& o, Value& v) { v = o.GetMaxChars(); return true; }
+bool PropSetNoBackground(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.NoBackground(v); return true; }
+bool PropGetNoBackground(const EditField& o, Value& v) { v = o.IsNoBackground(); return true; }
+bool PropSetAlignRight(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.AlignRight(v); return true; }
+bool PropGetAlignRight(const EditField& o, Value& v) { v = o.IsAlignRight(); return true; }
+
+CTRL_PROPERTIES(EditField, Ctrl)
+PROPERTY("password", PropSetPassword, PropGetPassword)
+PROPERTY("autoformat", PropSetAutoFormat, PropGetAutoFormat)
+PROPERTY("clickselect", PropSetClickSelect, PropGetClickSelect)
+PROPERTY("initcaps", PropSetInitCaps, PropGetInitCaps)
+PROPERTY("maxchars", PropSetMaxChars, PropGetMaxChars)
+PROPERTY("nobackground", PropSetNoBackground, PropGetNoBackground)
+PROPERTY("alignright", PropSetAlignRight, PropGetAlignRight)
+END_CTRL_PROPERTIES
+
+//EditString
+
+bool PropSetMaxLen(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.MaxLen(v); return true; }
+bool PropGetMaxLen(const EditString& o, Value& v) { v = o.GetMaxLength(); return true; }
+bool PropSetTrimLeft(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.TrimLeft(v); return true; }
+bool PropGetTrimLeft(const EditString& o, Value& v) { v = o.IsTrimLeft(); return true; }
+bool PropSetTrimRight(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.TrimRight(v); return true; }
+bool PropGetTrimRight(const EditString& o, Value& v) { v = o.IsTrimRight(); return true; }
+bool PropSetNotNull(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const EditString& o, Value& v) { v = o.IsNotNull(); return true; }
+
+CTRL_PROPERTIES(EditString, EditField)
+PROPERTY("maxlen", PropSetMaxLen, PropGetMaxLen)
+PROPERTY("trimleft", PropSetTrimLeft, PropGetTrimLeft)
+PROPERTY("trimrigth", PropSetTrimRight, PropGetTrimRight)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+END_CTRL_PROPERTIES
+
+//EditInt
+
+bool PropSetMin(EditInt& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; }
+bool PropGetMin(const EditInt& o, Value& v) { v = o.GetMin(); return true; }
+bool PropSetMax(EditInt& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; }
+bool PropGetMax(const EditInt& o, Value& v) { v = o.GetMax(); return true; }
+bool PropSetNotNull(EditInt& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const EditInt& o, Value& v) { v = o.IsNotNull(); return true; }
+
+CTRL_PROPERTIES(EditInt, EditField)
+PROPERTY("min", PropSetMin, PropGetMin)
+PROPERTY("max", PropSetMax, PropGetMax)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+END_CTRL_PROPERTIES
+
+//EditInt64
+
+bool PropSetMin(EditInt64& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; }
+bool PropGetMin(const EditInt64& o, Value& v) { v = o.GetMin(); return true; }
+bool PropSetMax(EditInt64& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; }
+bool PropGetMax(const EditInt64& o, Value& v) { v = o.GetMax(); return true; }
+bool PropSetNotNull(EditInt64& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const EditInt64& o, Value& v) { v = o.IsNotNull(); return true; }
+
+CTRL_PROPERTIES(EditInt64, EditField)
+PROPERTY("min", PropSetMin, PropGetMin)
+PROPERTY("max", PropSetMax, PropGetMax)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+END_CTRL_PROPERTIES
+
+//EditDouble
+
+bool PropSetMin(EditDouble& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; }
+bool PropGetMin(const EditDouble& o, Value& v) { v = o.GetMin(); return true; }
+bool PropSetMax(EditDouble& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; }
+bool PropGetMax(const EditDouble& o, Value& v) { v = o.GetMax(); return true; }
+bool PropSetNotNull(EditDouble& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const EditDouble& o, Value& v) { v = o.IsNotNull(); return true; }
+
+CTRL_PROPERTIES(EditDouble, EditField)
+PROPERTY("min", PropSetMin, PropGetMin)
+PROPERTY("max", PropSetMax, PropGetMax)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+END_CTRL_PROPERTIES
+
+//NotNull variants
+
+CTRL_PROPERTIES(EditIntNotNull, EditInt)
+END_CTRL_PROPERTIES
+
+CTRL_PROPERTIES(EditInt64NotNull, EditInt64)
+END_CTRL_PROPERTIES
+
+CTRL_PROPERTIES(EditDoubleNotNull, EditDouble)
+END_CTRL_PROPERTIES
+
+//EditIntSpin
+
+bool PropSetInc(EditIntSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.SetInc(v); return true; }
+bool PropGetInc(const EditIntSpin& o, Value& v) { v = o.GetInc(); return true; }
+bool PropSetShowSpin(EditIntSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowSpin(v); return true; }
+bool PropGetShowSpin(const EditIntSpin& o, Value& v) { v = o.IsShowSpin(); return true; }
+
+CTRL_PROPERTIES(EditIntSpin, EditInt)
+PROPERTY("inc", PropSetInc, PropGetInc)
+PROPERTY("showspin", PropSetShowSpin, PropGetShowSpin)
+END_CTRL_PROPERTIES
+
+//EditInt64Spin
+
+bool PropSetInc(EditInt64Spin& o, const Value& v) { if(!IsNumber(v)) return false; o.SetInc(v); return true; }
+bool PropGetInc(const EditInt64Spin& o, Value& v) { v = o.GetInc(); return true; }
+bool PropSetShowSpin(EditInt64Spin& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowSpin(v); return true; }
+bool PropGetShowSpin(const EditInt64Spin& o, Value& v) { v = o.IsShowSpin(); return true; }
+
+CTRL_PROPERTIES(EditInt64Spin, EditInt64)
+PROPERTY("inc", PropSetInc, PropGetInc)
+PROPERTY("showspin", PropSetShowSpin, PropGetShowSpin)
+END_CTRL_PROPERTIES
+
+//EditDoubleSpin
+
+bool PropSetInc(EditDoubleSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.SetInc(v); return true; }
+bool PropGetInc(const EditDoubleSpin& o, Value& v) { v = o.GetInc(); return true; }
+bool PropSetShowSpin(EditDoubleSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowSpin(v); return true; }
+bool PropGetShowSpin(const EditDoubleSpin& o, Value& v) { v = o.IsShowSpin(); return true; }
+
+CTRL_PROPERTIES(EditDoubleSpin, EditDouble)
+PROPERTY("inc", PropSetInc, PropGetInc)
+PROPERTY("showspin", PropSetShowSpin, PropGetShowSpin)
+END_CTRL_PROPERTIES
+
+//NotNull variants
+
+CTRL_PROPERTIES(EditIntNotNullSpin, EditIntSpin)
+END_CTRL_PROPERTIES
+
+CTRL_PROPERTIES(EditInt64NotNullSpin, EditInt64Spin)
+END_CTRL_PROPERTIES
+
+CTRL_PROPERTIES(EditDoubleNotNullSpin, EditDoubleSpin)
+END_CTRL_PROPERTIES
+
+//EditDate
+
+bool PropSetMin(EditDate& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; }
+bool PropGetMin(const EditDate& o, Value& v) { v = o.GetMin(); return true; }
+bool PropSetMax(EditDate& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; }
+bool PropGetMax(const EditDate& o, Value& v) { v = o.GetMax(); return true; }
+bool PropSetNotNull(EditDate& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const EditDate& o, Value& v) { v = o.IsNotNull(); return true; }
+
+CTRL_PROPERTIES(EditDate, EditField)
+PROPERTY("min", PropSetMin, PropGetMin)
+PROPERTY("max", PropSetMax, PropGetMax)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+END_CTRL_PROPERTIES
+
+//EditTime
+
+bool PropSetMin(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; }
+bool PropGetMin(const EditTime& o, Value& v) { v = o.GetMin(); return true; }
+bool PropSetMax(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; }
+bool PropGetMax(const EditTime& o, Value& v) { v = o.GetMax(); return true; }
+bool PropSetNotNull(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const EditTime& o, Value& v) { v = o.IsNotNull(); return true; }
+bool PropSetSeconds(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.Seconds(v); return true; }
+bool PropGetSeconds(const EditTime& o, Value& v) { v = o.IsSeconds(); return true; }
+
+CTRL_PROPERTIES(EditTime, EditField)
+PROPERTY("min", PropSetMin, PropGetMin)
+PROPERTY("max", PropSetMax, PropGetMax)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+PROPERTY("seconds", PropSetSeconds, PropGetSeconds)
+END_CTRL_PROPERTIES
+
+//NotNull variants
+
+CTRL_PROPERTIES(EditDateNotNull, EditDate)
+END_CTRL_PROPERTIES
+
+CTRL_PROPERTIES(EditTimeNotNull, EditTime)
+END_CTRL_PROPERTIES
--- a/bazaar/CtrlProp/PushCtrl.cpp
+++ b/bazaar/CtrlProp/PushCtrl.cpp
@ -0,0 +1,52 @@
+#include "CtrlProp.h"
+#include <CtrlLib/CtrlLib.h>
+
+bool PropSetLabel(Pusher& o, const Value& v) { if(!IsString(v)) return false; o.SetLabel(String(v)); return true; }
+bool PropGetLabel(const Pusher& o, Value& v) { v = o.GetLabel(); return true; }
+bool PropSetClickFocus(Pusher& o, const Value& v) { if(!IsNumber(v)) return false; o.ClickFocus(v); return true; }
+bool PropGetClickFocus(const Pusher& o, Value& v) { v = o.IsClickFocus(); return true; }
+bool PropGetVisualState(const Pusher& o, Value& v) { v = o.GetVisualState(); return true; }
+
+CTRL_PROPERTIES(Pusher, Ctrl)
+PROPERTY("label", PropSetLabel, PropGetLabel)
+PROPERTY("clickfocus", PropSetClickFocus, PropGetClickFocus)
+//PROPERTY_GET("visualstate", PropGetVisualState)
+END_CTRL_PROPERTIES
+
+CTRL_PROPERTIES(Button, Pusher)
+END_CTRL_PROPERTIES
+
+bool PropSetLabel(ButtonOption& o, const Value& v) { if(!IsString(v)) return false; o.SetLabel(v); return true; }
+bool PropGetLabel(const ButtonOption& o, Value& v) { v = o.GetLabel(); return true; }
+
+CTRL_PROPERTIES(ButtonOption, Ctrl)
+PROPERTY("label", PropSetLabel, PropGetLabel)
+END_CTRL_PROPERTIES
+
+bool PropSetBlackEdge(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.BlackEdge(v); return true; }
+bool PropGetBlackEdge(const Option& o, Value& v) { v = o.IsBlackEdge(); return true; }
+bool PropSetSwitchImage(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.SwitchImage(v); return true; }
+bool PropGetSwitchImage(const Option& o, Value& v) { v = o.IsSwitchImage(); return true; }
+bool PropSetThreeState(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.ThreeState(v); return true; }
+bool PropGetThreeState(const Option& o, Value& v) { v = o.IsThreeState(); return true; }
+bool PropSetShowLabel(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowLabel(v); return true; }
+bool PropGetShowLabel(const Option& o, Value& v) { v = o.IsShowLabel(); return true; }
+bool PropSetNotNull(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; }
+bool PropGetNotNull(const Option& o, Value& v) { v = o.IsNotNull(); return true; }
+
+CTRL_PROPERTIES(Option, Pusher)
+PROPERTY("blackedge", PropSetBlackEdge, PropGetBlackEdge)
+PROPERTY("switchimage", PropSetSwitchImage, PropGetSwitchImage)
+PROPERTY("threestate", PropSetThreeState, PropGetThreeState)
+PROPERTY("showlabel", PropSetShowLabel, PropGetShowLabel)
+PROPERTY("notnull", PropSetNotNull, PropGetNotNull)
+END_CTRL_PROPERTIES
+
+bool PropSetLabel(Switch& o, const Value& v) { o.SetLabel(AsString(v)); return true; }
+bool PropGetLabel(const Switch& o, Value& v) { v = o.GetLabel(); return true; }
+
+CTRL_PROPERTIES(Switch, Ctrl)
+PROPERTY("label", PropSetLabel, PropGetLabel)
+END_CTRL_PROPERTIES
+
+
--- a/bazaar/CtrlProp/SliderCtrl.cpp
+++ b/bazaar/CtrlProp/SliderCtrl.cpp
@ -0,0 +1,18 @@
+#include "CtrlProp.h"
+#include <CtrlLib/CtrlLib.h>
+
+//SliderCtrl
+
+bool PropSetMin(SliderCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; }
+bool PropGetMin(const SliderCtrl& o, Value& v) { v = o.GetMin(); return true; }
+bool PropSetMax(SliderCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; }
+bool PropGetMax(const SliderCtrl& o, Value& v) { v = o.GetMax(); return true; }
+bool PropSetStep(SliderCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Step(v); return true; }
+bool PropGetStep(const SliderCtrl& o, Value& v) { v = o.GetStep(); return true; }
+
+CTRL_PROPERTIES(SliderCtrl, Ctrl)
+PROPERTY("min", PropSetMin, PropGetMin)
+PROPERTY("max", PropSetMax, PropGetMax)
+PROPERTY("step", PropSetStep, PropGetStep)
+END_CTRL_PROPERTIES
+
--- a/bazaar/CtrlProp/StaticCtrl.cpp
+++ b/bazaar/CtrlProp/StaticCtrl.cpp
@ -0,0 +1,65 @@
+#include "CtrlProp.h"
+#include <CtrlLib/CtrlLib.h>
+
+//StaticText
+
+bool PropSetInk(StaticText& o, const Value& v) { if(!v.Is<Color>()) return false; o.SetInk(v); return true; }
+bool PropGetInk(const StaticText& o, Value& v) { v = o.GetInk(); return true; }
+bool PropSetText(StaticText& o, const Value& v) { o.SetText(AsString(v)); return true; }
+bool PropGetText(const StaticText& o, Value& v) { v = o.GetText(); return true; }
+bool PropSetAlign(StaticText& o, const Value& v) { if(!IsNumber(v)) return false; o.SetAlign(v); return true; }
+bool PropGetAlign(const StaticText& o, Value& v) { v = o.GetAlign(); return true; }
+
+CTRL_PROPERTIES(StaticText, Ctrl)
+PROPERTY("ink", PropSetInk, PropGetInk)
+PROPERTY("text", PropSetText, PropGetText)
+PROPERTY("align", PropSetAlign, PropGetAlign)
+END_CTRL_PROPERTIES
+
+//Label
+
+bool PropSetText(Label& o, const Value& v) { o.SetText(AsString(v)); return true; }
+bool PropGetText(const Label& o, Value& v) { v = o.GetText(); return true; }
+
+CTRL_PROPERTIES(Label, StaticText)
+PROPERTY("text", PropSetText, PropGetText)
+END_CTRL_PROPERTIES
+
+//LabelBox
+
+CTRL_PROPERTIES(LabelBox, Label)
+END_CTRL_PROPERTIES
+
+//ParentCtrl
+
+CTRL_PROPERTIES(ParentCtrl, Ctrl)
+END_CTRL_PROPERTIES
+
+//StaticRect
+
+bool PropSetBackground(StaticRect& o, const Value& v) { if(!v.Is<Color>()) return false; o.Background(v); return true; }
+bool PropGetBackground(const StaticRect& o, Value& v) { v = o.GetBackground(); return true; }
+
+CTRL_PROPERTIES(StaticRect, Ctrl)
+PROPERTY("background", PropSetBackground, PropGetBackground)
+END_CTRL_PROPERTIES
+
+//ImageCtrl
+
+CTRL_PROPERTIES(ImageCtrl, Ctrl)
+END_CTRL_PROPERTIES
+
+//DisplayCtrl
+
+CTRL_PROPERTIES(DisplayCtrl, Ctrl)
+END_CTRL_PROPERTIES
+
+//Picture
+
+CTRL_PROPERTIES(Picture, Ctrl)
+END_CTRL_PROPERTIES
+
+//SeparatorCtrl
+
+CTRL_PROPERTIES(SeparatorCtrl, Ctrl)
+END_CTRL_PROPERTIES
--- a/bazaar/CtrlProp/TextEdit.cpp
+++ b/bazaar/CtrlProp/TextEdit.cpp
@ -0,0 +1,53 @@
+#include "CtrlProp.h"
+#include <CtrlLib/CtrlLib.h>
+
+//TextCtrl
+
+bool PropSetUndoSteps(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.UndoSteps(v); return true; }
+bool PropGetUndoSteps(const TextCtrl& o, Value& v) { v = o.GetUndoSteps(); return true; }
+bool PropSetProcessTab(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.ProcessTab(v); return true; }
+bool PropGetProcessTab(const TextCtrl& o, Value& v) { v = o.IsProcessTab(); return true; }
+bool PropSetProcessEnter(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.ProcessEnter(v); return true; }
+bool PropGetProcessEnter(const TextCtrl& o, Value& v) { v = o.IsProcessEnter(); return true; }
+bool PropSetNoBackground(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.NoBackground(v); return true; }
+bool PropGetNoBackground(const TextCtrl& o, Value& v) { v = o.IsNoBackground(); return true; }
+
+CTRL_PROPERTIES(TextCtrl, Ctrl)
+PROPERTY("undosteps", PropSetUndoSteps, PropGetUndoSteps)
+PROPERTY("processtab", PropSetProcessTab, PropGetProcessTab)
+PROPERTY("processenter", PropSetProcessEnter, PropGetProcessEnter)
+PROPERTY("nobackground", PropSetNoBackground, PropGetNoBackground)
+END_CTRL_PROPERTIES
+
+//LineEdit
+
+bool PropSetTabSize(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.TabSize(v); return true; }
+bool PropGetTabSize(const LineEdit& o, Value& v) { v = o.GetTabSize(); return true; }
+bool PropSetShowTabs(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowTabs(v); return true; }
+bool PropGetShowTabs(const LineEdit& o, Value& v) { v = o.IsShowTabs(); return true; }
+bool PropSetCutLine(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.WithCutLine(v); return true; }
+bool PropGetCutLine(const LineEdit& o, Value& v) { v = o.IsWithCutLine(); return true; }
+bool PropSetNoHorzScrollbar(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.NoHorzScrollbar(v); return true; }
+bool PropGetNoHorzScrollbar(const LineEdit& o, Value& v) { v = o.IsNoHorzScrollbar(); return true; }
+
+CTRL_PROPERTIES(LineEdit, TextCtrl)
+PROPERTY("tabsize", PropSetTabSize, PropGetTabSize)
+PROPERTY("showtabs", PropSetShowTabs, PropGetShowTabs)
+PROPERTY("cutline", PropSetCutLine, PropGetCutLine)
+PROPERTY("nohorzsb", PropSetNoHorzScrollbar, PropGetNoHorzScrollbar)
+END_CTRL_PROPERTIES
+
+//DocEdit
+
+bool PropSetAutoHideSb(DocEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.AutoHideSb(v); return true; }
+bool PropGetAutoHideSb(const DocEdit& o, Value& v) { v = o.IsAutoHideSb(); return true; }
+bool PropSetUpDownLeave(DocEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.UpDownLeave(v); return true; }
+bool PropGetUpDownLeave(const DocEdit& o, Value& v) { v = o.IsUpDownLeave(); return true; }
+bool PropSetEofLine(DocEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.EofLine(v); return true; }
+bool PropGetEofLine(const DocEdit& o, Value& v) { v = o.IsEofLine(); return true; }
+
+CTRL_PROPERTIES(DocEdit, TextCtrl)
+PROPERTY("autohidesb", PropSetAutoHideSb, PropGetAutoHideSb)
+PROPERTY("updownleave", PropSetUpDownLeave, PropGetUpDownLeave)
+PROPERTY("eofline", PropSetEofLine, PropGetEofLine)
+END_CTRL_PROPERTIES
--- a/bazaar/CtrlProp/init
+++ b/bazaar/CtrlProp/init
@ -0,0 +1,6 @@
+#ifndef _CtrlProp_icpp_init_stub
+#define _CtrlProp_icpp_init_stub
+#include "CtrlLib/init"
+#include "LogPosCtrl/init"
+#include "ValueCtrl/init"
+#endif
--- a/bazaar/CtrlPropTest/CtrlPropTest.h
+++ b/bazaar/CtrlPropTest/CtrlPropTest.h
@ -0,0 +1,50 @@
+#ifndef _CtrlPropTest_CtrlPropTest_h
+#define _CtrlPropTest_CtrlPropTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define LAYOUTFILE <CtrlPropTest/CtrlPropTest.lay>
+#include <CtrlCore/lay.h>
+
+#include <CtrlProp/CtrlProp.h>
+#include <CtrlFinder/CtrlFinder.h>
+#include <RectCtrl/RectCtrl.h>
+
+bool MyMouseHook(Ctrl *ctrl, bool inframe, int event, Point p,
+	                          int zdelta, dword keyflags);
+void DoList(Ctrl& c);
+void DoEdit(Ctrl& c);
+bool CanEdit();
+
+class CtrlPropTest : public WithCtrlPropTestLayout<TopWindow> {
+public:
+	typedef CtrlPropTest CLASSNAME;
+	CtrlPropTest();
+
+	//hook
+	void EditCB();
+
+	void OnCtrlLeft(Ctrl& c, Point p, dword keyflags);
+	void OnCtrlRight(Ctrl& c, Point p, dword keyflags);
+	void OnRectChange();
+	void OnMissed(Point p, dword keyflags);
+
+	//misc
+	void Test();
+	void InitDummies();
+
+public:
+	ToolBar mb;
+	ToolBar::Item * mbi;
+	CtrlFinder hk;
+	RectCtrl rc;
+	RectCtrl::Style rcst;
+	Ptr<Ctrl> ctrl;
+	
+	Array<Ctrl> arc;
+};
+
+#endif
+
--- a/bazaar/CtrlPropTest/CtrlPropTest.lay
+++ b/bazaar/CtrlPropTest/CtrlPropTest.lay
@ -0,0 +1,45 @@
+LAYOUT(CtrlPropTestLayout, 768, 472)
+	ITEM(DocEdit, de, Tip(t_("DocEdit")).LeftPosZ(0, 152).TopPosZ(0, 44))
+	ITEM(LineEdit, le, Tip(t_("LineEdit")).LeftPosZ(0, 152).TopPosZ(48, 19))
+	ITEM(EditField, ef, Tip(t_("EditField")).LeftPosZ(0, 152).TopPosZ(72, 19))
+	ITEM(EditString, es, Tip(t_("EditString")).LeftPosZ(0, 152).TopPosZ(96, 19))
+	ITEM(Button, b, SetLabel(t_("Button")).Tip(t_("Button")).LeftPosZ(156, 56).TopPosZ(0, 20))
+	ITEM(Option, o, SetLabel(t_("Option")).Tip(t_("Option")).LeftPosZ(156, 56).TopPosZ(24, 16))
+	ITEM(Switch, sw, SetLabel(t_("Switch\nother")).LeftPosZ(156, 56).TopPosZ(48, 44))
+	ITEM(ButtonOption, bo, LeftPosZ(156, 56).TopPosZ(96, 20))
+	ITEM(DataPusher, dp, Tip(t_("DataPusher")).LeftPosZ(216, 92).TopPosZ(0, 20))
+	ITEM(SliderCtrl, sl, LeftPosZ(216, 92).TopPosZ(24, 20))
+	ITEM(Label, l, SetLabel(t_("Label")).LeftPosZ(312, 64).TopPosZ(0, 19))
+	ITEM(LabelBox, lb, SetLabel(t_("LabelBox")).LeftPosZ(312, 64).TopPosZ(24, 92))
+	ITEM(StaticText, st, SetText(t_("StaticText")).LeftPosZ(216, 92).TopPosZ(96, 19))
+	ITEM(RichTextCtrl, rtc, LeftPosZ(216, 92).TopPosZ(48, 19))
+	ITEM(EditInt, ei, Tip(t_("EditInt")).LeftPosZ(0, 76).TopPosZ(124, 19))
+	ITEM(EditInt64, ei64, Tip(t_("EditInt64")).LeftPosZ(0, 76).TopPosZ(144, 19))
+	ITEM(EditDouble, ed, Tip(t_("EditDouble")).LeftPosZ(0, 76).TopPosZ(164, 19))
+	ITEM(EditIntNotNull, einn, Tip(t_("EditIntNotNull")).LeftPosZ(76, 76).TopPosZ(124, 19))
+	ITEM(EditInt64NotNull, ei64nn, LeftPosZ(76, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleNotNull, ednn, Tip(t_("EditDoubleNotNull")).LeftPosZ(76, 76).TopPosZ(164, 19))
+	ITEM(EditIntSpin, eis, Tip(t_("EditIntSpin")).LeftPosZ(156, 76).TopPosZ(124, 19))
+	ITEM(EditInt64Spin, ei64s, LeftPosZ(156, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleSpin, eds, Tip(t_("EditDoubleSpin")).LeftPosZ(156, 76).TopPosZ(164, 19))
+	ITEM(EditIntNotNullSpin, einns, LeftPosZ(236, 76).TopPosZ(124, 19))
+	ITEM(EditInt64NotNullSpin, ei64nns, LeftPosZ(236, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleNotNullSpin, ednns, LeftPosZ(236, 76).TopPosZ(164, 19))
+	ITEM(EditDate, edt, Tip(t_("EditDate")).LeftPosZ(0, 76).TopPosZ(192, 19))
+	ITEM(EditTime, etm, Tip(t_("EditTime")).LeftPosZ(0, 76).TopPosZ(212, 19))
+	ITEM(EditDateNotNull, edtnn, LeftPosZ(76, 76).TopPosZ(192, 19))
+	ITEM(EditTimeNotNull, etmnn, LeftPosZ(76, 76).TopPosZ(212, 19))
+	ITEM(ProgressIndicator, pi, LeftPosZ(264, 112).TopPosZ(192, 20))
+	ITEM(Progress, pr, LeftPosZ(276, 100).TopPosZ(212, 20))
+	ITEM(DropDate, ddt, LeftPosZ(156, 104).TopPosZ(192, 19))
+	ITEM(DropTime, dtm, LeftPosZ(156, 120).TopPosZ(212, 19))
+	ITEM(DropList, dl, LeftPosZ(0, 220).TopPosZ(344, 19))
+	ITEM(ArrayCtrl, ac, LeftPosZ(0, 220).TopPosZ(236, 104))
+	ITEM(RichTextView, rtv, LeftPosZ(216, 92).TopPosZ(72, 19))
+	ITEM(TabCtrl, tb, LeftPosZ(224, 220).TopPosZ(236, 104))
+	ITEM(Clock, clk, LeftPosZ(380, 150).TopPosZ(0, 156))
+	ITEM(Calendar, cl, LeftPosZ(532, 236).TopPosZ(0, 156))
+	ITEM(DropTree, dtr, LeftPosZ(224, 220).TopPosZ(344, 19))
+	ITEM(TreeCtrl, tr, LeftPosZ(448, 160).TopPosZ(160, 204))
+END_LAYOUT
+
--- a/bazaar/CtrlPropTest/CtrlPropTest.upp
+++ b/bazaar/CtrlPropTest/CtrlPropTest.upp
@ -0,0 +1,20 @@
+description "Ctrl Properties editor, grabber, resizer..\377";
+
+uses
+	CtrlLib,
+	CtrlProp,
+	CtrlFinder,
+	RectCtrl;
+
+file
+	CtrlPropTest.h,
+	main.cpp,
+	edit.cpp,
+	find.cpp,
+	hook.cpp,
+	misc.cpp,
+	CtrlPropTest.lay;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/CtrlPropTest/edit.cpp
+++ b/bazaar/CtrlPropTest/edit.cpp
@ -0,0 +1,40 @@
+#include "CtrlPropTest.h"
+
+void DoEdit(Ctrl& c)
+{
+	PropEdit& pe = Single<PropEdit>();
+	if(pe.IsOpen()) return;
+
+	Ctrl* owner = Ctrl::GetActiveWindow();
+	if(!owner)
+	{
+		Exclamation("No Active Window");
+		return;	
+	}
+
+	pe.Rejector(); pe.PopUp(owner, c);
+}
+
+void DoList(Ctrl& c)
+{
+	PropList& pe = Single<PropList>();
+	if(pe.IsOpen()) return;
+
+	Ctrl* owner = Ctrl::GetActiveWindow();
+	if(!owner)
+	{
+		Exclamation("No Active Window");
+		return;	
+	}
+
+	pe.Rejector(); pe.PopUp(owner, c);
+}
+
+bool CanEdit()
+{
+	PropEdit& pe = Single<PropEdit>();
+	if(pe.IsOpen()) return false;
+	PropList& pl = Single<PropList>();
+	if(pl.IsOpen()) return false;
+	return true;
+}
--- a/bazaar/CtrlPropTest/find.cpp
+++ b/bazaar/CtrlPropTest/find.cpp
@ -0,0 +1,34 @@
+#include "CtrlPropTest.h"
+
+void CtrlPropTest::OnCtrlLeft(Ctrl& c, Point p, dword keyflags)
+{
+	if(&c == &rc) return;
+	if(&c == &hk) return;
+	if(!CanEdit()) return;
+	rc.SetData(c.GetRect());
+	Add(rc.SizePos());
+	ctrl = &c;
+}
+
+void CtrlPropTest::OnCtrlRight(Ctrl& c, Point p, dword keyflags)
+{
+	if(&c == &rc) return;
+	if(&c == &hk) return;
+	if(!CanEdit()) return;
+	if(keyflags == K_SHIFT)
+		DoList(c);
+	else
+		DoEdit(c);
+}
+
+void CtrlPropTest::OnRectChange()
+{
+	if(!ctrl) return;
+	ctrl->SetRect(rc.GetData());
+}
+
+void CtrlPropTest::OnMissed(Point p, dword keyflags)
+{
+	rc.Remove(); //leave move
+	hk.LeftDown(p, keyflags);
+}
--- a/bazaar/CtrlPropTest/hook.cpp
+++ b/bazaar/CtrlPropTest/hook.cpp
@ -0,0 +1,26 @@
+#include "CtrlPropTest.h"
+
+bool MyMouseHook(Ctrl *ctrl, bool inframe, int event, Point p,
+	                          int zdelta, dword keyflags)
+{
+	if(event & (Ctrl::MOUSEMOVE | Ctrl::MOUSEENTER | Ctrl::MOUSELEAVE | Ctrl::CURSORIMAGE)) return false;
+	if((keyflags & K_MOUSERIGHT))
+	if((keyflags & K_SHIFT_CTRL))
+	{
+		if(!CanEdit()) return false;
+		
+		CallbackArgTarget<int> m;
+		MenuBar menu;
+		menu.Add("List Properties",m[0]);
+		menu.Add("Edit Properties",m[1]);
+		menu.Execute();
+		if(IsNull(m)) return true;
+		switch(m)
+		{
+			case 0: DoList(*ctrl); break;
+			case 1: DoEdit(*ctrl); break;
+		}
+		return true;
+	}
+	return false;
+}
--- a/bazaar/CtrlPropTest/init
+++ b/bazaar/CtrlPropTest/init
@ -0,0 +1,7 @@
+#ifndef _CtrlPropTest_icpp_init_stub
+#define _CtrlPropTest_icpp_init_stub
+#include "CtrlLib/init"
+#include "CtrlProp/init"
+#include "CtrlFinder/init"
+#include "RectCtrl/init"
+#endif
--- a/bazaar/CtrlPropTest/main.cpp
+++ b/bazaar/CtrlPropTest/main.cpp
@ -0,0 +1,46 @@
+#include "CtrlPropTest.h"
+
+void CtrlPropTest::EditCB()
+{
+	if(hk.IsEnabled())
+	{
+		hk.Disable();
+		mbi->Check(false);
+	}
+	else
+	{
+		SetFocus(); //kill foucus from all others
+		hk.Enable();
+		rc.Remove();
+		mbi->Check(true);
+	}
+}
+
+CtrlPropTest::CtrlPropTest()
+{
+	CtrlLayout(*this, "Window title");
+
+	mbi = &mb.Add(!IsReadOnly(), t_("Edit"), CtrlImg::selection(),
+	        THISBACK(EditCB));
+	AddFrame(mb);
+
+	InstallMouseHook(&MyMouseHook);
+
+	hk.WhenLeftDown = THISBACK(OnCtrlLeft);
+	hk.WhenRightDown = THISBACK(OnCtrlRight);
+	hk.Disable();
+	Add(hk.SizePos());
+
+	rcst = RectCtrl::StyleDefault();	
+	rcst.rectcol = Null;
+	rc.SetStyle(rcst);
+	rc <<= THISBACK(OnRectChange);
+	rc.WhenMissed = THISBACK(OnMissed);
+
+	InitDummies();
+}
+	
+GUI_APP_MAIN
+{
+	CtrlPropTest().Run();
+}
--- a/bazaar/CtrlPropTest/misc.cpp
+++ b/bazaar/CtrlPropTest/misc.cpp
@ -0,0 +1,123 @@
+#include "CtrlPropTest.h"
+
+void CtrlPropTest::InitDummies()
+{
+	bo.SetLabel("MyCtrlsImg");
+	
+	de.SetData("This is a\nDocEdit example text");
+	le.SetData("LineEdit");
+	ef.SetData("EditField");
+	es.SetData("EditString");
+	
+	ei = 100;
+	ei64 = 22342599399929;
+	ed = 10.3;
+	
+	einn <<= 100;
+	ei64nn <<= 22342599399929;
+	ednn <<= 10.3;
+
+	eis <<= 100;
+	ei64s <<= 22342599399929;
+	eds <<= 10.3;
+
+	einns <<= 100;
+	ei64nns <<= 22342599399929;
+	ednns <<= 10.3;
+	
+	edt <<= GetSysDate();
+	etm <<= GetSysTime();
+
+	edtnn <<= GetSysDate();
+	etmnn <<= GetSysTime();
+
+	ddt <<= GetSysDate();
+	dtm <<= GetSysTime();
+	
+	ac.AddColumn("One");
+	ac.AddColumn("Two");
+	ac.Add("Hello", 1234);
+	ac.Add(23.8, "servus");
+	ac.Add("foo", true);
+	ac.Add("bar", "lee");
+
+	sl <<= 0;
+	
+	dl.Add(0,"First");
+	dl.Add(1,"Second");
+	dl.Add(2,"Third");
+	dl.Add(3,"Fourth");
+	
+	
+	Vector<int> parent, parent2;
+	parent.Add(0);
+	tr.SetRoot(Image(), "The Tree");
+	for(int i = 1; i < 10000; i++) {
+		parent.Add(tr.Add(parent[rand() % parent.GetCount()], Image(),
+		            FormatIntRoman(i, true)));
+		if((rand() & 3) == 0)
+			tr.Open(parent.Top());
+	}
+	tr.Open(0);
+
+	{
+	TreeCtrl& tree = dtr->MultiSelect();
+	Vector<int> parent, parent2;
+	parent.Add(0);
+	tree.SetRoot(Image(), "The Tree");
+	for(int i = 1; i < 10000; i++) {
+		parent.Add(tree.Add(parent[rand() % parent.GetCount()], Image(),
+		            FormatIntRoman(i, true)));
+		if((rand() & 3) == 0)
+			tree.Open(parent.Top());
+	}
+	tree.Open(0);
+	}
+	
+	tb.Add(arc.Add(new EditInt()).SizePos(),"First");
+	tb.Add(arc.Add(new EditInt()).SizePos(),"Second");
+	tb.Add(arc.Add(new EditInt()).SizePos(),"Third");
+}
+
+void CtrlPropTest::Test()
+{
+	EditInt ei;	
+	bool b;
+
+	ei.Tip("Tooltip for this one");
+
+	b = SetProperty(ei, "data", 10);
+	RLOG(b);
+
+	Value v;
+	b = GetProperty(ei, "data", v);
+	RLOG(b << v);
+	
+	b = SetProperty(ei, "min", -100);
+	RLOG(b);
+	b = SetProperty(ei, "max", 100);
+	RLOG(b);
+	
+	b = GetProperty(ei, "min", v);
+	RLOG(b << v);
+	b = GetProperty(ei, "max", v);
+	RLOG(b << v);
+	
+	v = Value();
+	b = GetProperty(ei, "listset", v);
+	RLOG(b << v);
+	
+	v = Value();
+	b = GetProperty(ei, "listget", v);
+	RLOG(b << v);
+	
+	ValueArray va = v;
+	for(int i = 0; i < va.GetCount(); i++)
+	{
+		String s = va.Get(i);
+		RLOG(s);
+		v = Value();
+		b = GetProperty(ei, s, v);
+		RLOG(v << "\n");
+	}
+}
--- a/bazaar/Iter/Iter.cpp
+++ b/bazaar/Iter/Iter.cpp
@ -0,0 +1 @@
+#include "Iter.h"
--- a/bazaar/Iter/Iter.h
+++ b/bazaar/Iter/Iter.h
@ -0,0 +1,323 @@
+#ifndef _Iter_Iter_h
+#define _Iter_Iter_h
+
+#include <Core/Core.h>
+using namespace Upp;
+
+#include <Gen/Gen.h>
+
+template<class T>
+class ConstIter : public Copyable<ConstIter<T> >
+{
+public:
+	virtual void Reset() = 0;
+	virtual const T& Get() const = 0;
+	virtual bool Next() = 0;
+
+	const T& operator*()              { return Get(); }
+	const T *operator->()             { return &Get(); }
+
+	ConstIter& operator++()           { Next(); return *this; }
+	//cant use postfix because need to 'clone' the iter from base class
+	//and this can only happen on heap, cant return on stack
+	//ConstIter  operator++(int)        { ConstIter t = *this; ++ii; return t; }
+};
+
+template<class T>
+class Iter : public Copyable<Iter<T> >
+{
+public:
+	virtual void Reset() = 0;
+	virtual T& Get() const = 0;
+	virtual bool Next() = 0;
+
+	T& operator*()              { return Get(); }
+	T *operator->()             { return &Get(); }
+
+	Iter& operator++()          { Next(); return *this; }
+	//cant use postfix because need to 'clone' the iter from base class
+	//and this can only happen on heap, cant return on stack
+	//Iter  operator++(int)       { Iter t = *this; ++ii; return t; }
+};
+
+template<class T, class V>
+class ConstIterCont : public ConstIter<T>
+{
+	friend class IterCreator;
+protected:
+	const V* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual const T& Get() const { return (*cont)[ii]; }
+	virtual bool Next() { return (++ii < cont->GetCount()); }
+
+	virtual ConstIterCont* Copy() const { return new ConstIterCont(*this); }
+	virtual ConstIterCont* PartialCopy() const { ConstIterCont* t = Copy(); t->Reset(); return t; }
+	
+	ConstIterCont() : cont(NULL), ii(-1) {}
+	ConstIterCont(const V& _cont) : cont(&_cont), ii(-1) {}
+	ConstIterCont(const V& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+template<class T, class V>
+class IterCont : public Iter<T>
+{
+	friend class IterCreator;
+protected:
+	V* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual T& Get() const { return (*cont)[ii]; }
+	virtual bool Next() { return (++ii < cont->GetCount()); }
+
+	virtual IterCont* Copy() const { return new IterCont(*this); }
+	virtual IterCont* PartialCopy() const { IterCont* t = Copy(); t->Reset(); return t; }
+	
+	IterCont() : cont(NULL), ii(-1) {}
+	IterCont(V& _cont) : cont(&_cont), ii(-1) {}
+	IterCont(V& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+#define ITER_CONT(Cont) \
+	template<class T> inline static Iter<T>* GetIter(Cont& cont) { return new IterCont<T,Cont >(cont); } \
+	template<class T> inline static Iter<T>* GetIter(Cont& cont, int ii) { return new IterCont<T,Cont >(cont, ii); } \
+	template<class T> inline static ConstIter<T>* GetIter(const Cont& cont) { return new ConstIterCont<T,Cont >(cont); } \
+	template<class T> inline static ConstIter<T>* GetIter(const Cont& cont, int ii) { return new ConstIterCont<T,Cont >(cont, ii); } \
+
+
+template<class T, class V>
+class ConstIterPtr : public ConstIter<T>
+{
+	friend class IterCreator;
+protected:
+	const V* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual const T& Get() const { ASSERT(ii==0); return *(*cont); }
+	virtual bool Next() { return (++ii < 1); }
+
+	virtual ConstIterPtr* Copy() const { return new ConstIterPtr(*this); }
+	virtual ConstIterPtr* PartialCopy() const { ConstIterPtr* t = Copy(); t->Reset(); return t; }
+	
+	ConstIterPtr() : cont(NULL), ii(-1) {}
+	ConstIterPtr(const V& _cont) : cont(&_cont), ii(-1) {}
+	ConstIterPtr(const V& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+template<class T, class V>
+class IterPtr : public Iter<T>
+{
+	friend class IterCreator;
+protected:
+	V* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual T& Get() const { ASSERT(ii==0); return *(*cont); }
+	virtual bool Next() { return (++ii < 1); }
+
+	virtual IterPtr* Copy() const { return new IterPtr(*this); }
+	virtual IterPtr* PartialCopy() const { IterPtr* t = Copy(); t->Reset(); return t; }
+	
+	IterPtr() : cont(NULL), ii(-1) {}
+	IterPtr(V& _cont) : cont(&_cont), ii(-1) {}
+	IterPtr(V& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+#define ITER_PTR(Cont) \
+	template<class T> inline static Iter<T>* GetIter(Cont& cont) { return new IterPtr<T,Cont >(cont); } \
+	template<class T> inline static ConstIter<T>* GetIter(const Cont& cont) { return new ConstIterPtr<T,Cont >(cont); } \
+
+
+template<class T>
+class ConstIterAny : public ConstIter<T>
+{
+	friend class IterCreator;
+protected:
+	const Any* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual const T& Get() const { ASSERT(ii==0); ASSERT(cont->Is<T>()); return cont->Get<T>(); }
+	virtual bool Next() { return (++ii < 1); }
+
+	virtual ConstIterAny* Copy() const { return new ConstIterAny(*this); }
+	virtual ConstIterAny* PartialCopy() const { ConstIterAny* t = Copy(); t->Reset(); return t; }
+	
+	ConstIterAny() : cont(NULL), ii(-1) {}
+	ConstIterAny(const Any& _cont) : cont(&_cont), ii(-1) {}
+	ConstIterAny(const Any& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+template<class T>
+class IterAny : public Iter<T>
+{
+	friend class IterCreator;
+protected:
+	Any *cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual T& Get() const { ASSERT(ii==0); ASSERT(cont->Is<T>()); return cont->Get<T>(); }
+	virtual bool Next() { return (++ii < 1); }
+
+	virtual IterAny* Copy() const { return new IterAny(*this); }
+	virtual IterAny* PartialCopy() const { IterAny* t = Copy(); t->Reset(); return t; }
+	
+	IterAny() : cont(NULL), ii(-1) {}
+	IterAny(Any& _cont) : cont(&_cont), ii(-1) {}
+	IterAny(Any& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+template<class T>
+class ConstIterValue : public ConstIter<T>
+{
+	friend class IterCreator;
+protected:
+	const Value* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual const T& Get() const { ASSERT(ii==0); ASSERT(cont->Is<T>()); return ValueTo<T>(*cont); }
+	virtual bool Next() { return (++ii < 1); }
+
+	virtual ConstIterValue* Copy() const { return new ConstIterValue(*this); }
+	virtual ConstIterValue* PartialCopy() const { ConstIterValue* t = Copy(); t->Reset(); return t; }
+	
+	ConstIterValue() : cont(NULL), ii(-1) {}
+	ConstIterValue(const Value& _cont) : cont(&_cont), ii(-1) {}
+	ConstIterValue(const Value& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+template<class T>
+class IterValue : public Iter<T>
+{
+	friend class IterCreator;
+protected:
+	Value* cont;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; }
+	virtual T& Get() const { ASSERT(ii==0); ASSERT(cont->Is<T>()); return const_cast<T&>(ValueTo<T>(*cont)); }
+	virtual bool Next() { return (++ii < 1); }
+
+	virtual IterValue* Copy() const { return new IterValue(*this); }
+	virtual IterValue* PartialCopy() const { IterValue* t = Copy(); t->Reset(); return t; }
+	
+	IterValue() : cont(NULL), ii(-1) {}
+	IterValue(Value& _cont) : cont(&_cont), ii(-1) {}
+	IterValue(Value& _cont, int ii) : cont(&_cont), ii(ii) {}
+};
+
+template<class T>
+class ConstIterLink : public ConstIter<T>
+{
+	friend class IterCreator;
+protected:
+	const Link<T>* cont;
+	const Link<T>* start;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; cont = start; }
+	virtual const T& Get() const { ASSERT(ii>=0); return *cont->GetPtr(); }
+	virtual bool Next() { ++ii; return ((cont = cont->GetNext()) != start); }
+
+	virtual ConstIterLink* Copy() const { return new ConstIterLink(*this); }
+	virtual ConstIterLink* PartialCopy() const { ConstIterLink* t = Copy(); t->Reset(); return t; }
+	
+	ConstIterLink() : cont(NULL), ii(-1) {}
+	ConstIterLink(const Link<T>& _cont) : cont(&_cont), start(&_cont), ii(-1) {}
+	ConstIterLink(const Link<T>& _cont, int ii) : cont(&_cont), start(&_cont), ii(ii) {}
+};
+
+template<class T>
+class IterLink : public Iter<T>
+{
+	friend class IterCreator;
+protected:
+	Link<T>* cont;
+	Link<T>* start;
+	int ii;
+
+public:
+	virtual void Reset() { ii = -1; cont = start; }
+	virtual T& Get() const { ASSERT(ii>=0); return *cont->GetPtr(); }
+	virtual bool Next() { ++ii; return ((cont = cont->GetNext()) != start); }
+
+	virtual IterLink* Copy() const { return new IterLink(*this); }
+	virtual IterLink* PartialCopy() const { IterLink* t = Copy(); t->Reset(); return t; }
+	
+	IterLink() : cont(NULL), ii(-1) {}
+	IterLink(Link<T>& _cont) : cont(&_cont), start(&_cont), ii(-1) {}
+	IterLink(Link<T>& _cont, int ii) : cont(&_cont), start(&_cont), ii(ii) {}
+};
+
+class IterCreator
+{
+public:
+
+ITER_CONT(Vector<T>)
+ITER_CONT(Array<T>)
+ITER_CONT(BiVector<T>)
+ITER_CONT(BiArray<T>)
+ITER_CONT(Index<T>)
+ITER_CONT(ArrayIndex<T>)
+ITER_CONT(Segtor<T>)
+
+ITER_PTR(Ptr<T>)
+ITER_PTR(One<T>)
+ITER_PTR(T*)
+
+	template<class T> inline static Iter<T>* GetIter(Any& cont) { ASSERT(cont.Is<T>()); return new IterAny<T>(cont); } \
+	template<class T> inline static ConstIter<T>* GetIter(const Any& cont) { ASSERT(cont.Is<T>()); return new ConstIterAny<T>(cont); } \
+
+	template<class T> inline static Iter<T>* GetIter(Value& cont) { ASSERT(cont.Is<T>()); return new IterValue<T>(cont); } \
+	template<class T> inline static ConstIter<T>* GetIter(const Value& cont) { ASSERT(cont.Is<T>()); return new ConstIterValue<T>(cont); } \
+
+	template<class T> inline static Iter<T>* GetIter(Link<T>& cont) { return new IterLink<T>(cont); } \
+	template<class T> inline static ConstIter<T>* GetIter(const Link<T>& cont) { return new ConstIterLink<T>(cont); } \
+
+private:
+	IterCreator();
+	IterCreator(const IterCreator&);
+	~IterCreator();
+};
+
+//use these to manage scope destrying
+#define ITER(type) One<Iter<type> >
+#define ITERC(type) One<ConstIter<type> >
+
+#define FOREACHCONT(type, var, cont) \
+for(int __i = 0, __c = (cont).GetCount(), __b; __b = 1,__i < __c; ++__i) \
+	for(type& var = (cont)[__i]; __b; __b = 0) \
+
+
+#define FOREACHCONTC(type, var, cont) \
+for(int __i = 0, __c = (cont).GetCount(), __b; __b = 1,__i < __c; ++__i) \
+	for(const type& var = (cont)[__i]; __b; __b = 0) \
+
+
+#define FOREACH(type, var, cont) \
+if(int __b = 1) \
+for(One<Iter<type> > __it = IterCreator::GetIter<type>(cont); __b = 1, __it->Next(); ) \
+	for(type& var = __it->Get(); __b; __b = 0)\
+
+
+#define FOREACHC(type, var, cont) \
+if(int __b = 1) \
+for(One<ConstIter<type> > __it = IterCreator::GetIter<type>(cont); __b = 1, __it->Next(); ) \
+	for(const type& var = __it->Get(); __b; __b = 0)\
+
+#endif
--- a/bazaar/Iter/Iter.upp
+++ b/bazaar/Iter/Iter.upp
@ -0,0 +1,10 @@
+description "Iterator Interface for common containers\377";
+
+uses
+	Core,
+	Gen;
+
+file
+	Iter.h,
+	Iter.cpp;
+
--- a/bazaar/Iter/init
+++ b/bazaar/Iter/init
@ -0,0 +1,5 @@
+#ifndef _Iter_icpp_init_stub
+#define _Iter_icpp_init_stub
+#include "Core/init"
+#include "Gen/init"
+#endif
--- a/bazaar/IterTest/IterTest.h
+++ b/bazaar/IterTest/IterTest.h
@ -0,0 +1,27 @@
+#ifndef _IterTest_IterTest_h
+#define _IterTest_IterTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define LAYOUTFILE <IterTest/IterTest.lay>
+#include <CtrlCore/lay.h>
+
+#include <Iter/Iter.h>
+
+class Foo : public Link<Foo>
+{
+public:
+	int d;
+};
+
+
+class IterTest : public WithIterTestLayout<TopWindow> {
+public:
+	typedef IterTest CLASSNAME;
+	IterTest();
+};
+
+#endif
+
--- a/bazaar/IterTest/IterTest.lay
+++ b/bazaar/IterTest/IterTest.lay
@ -0,0 +1,3 @@
+LAYOUT(IterTestLayout, 200, 100)
+END_LAYOUT
+
--- a/bazaar/IterTest/IterTest.upp
+++ b/bazaar/IterTest/IterTest.upp
@ -0,0 +1,14 @@
+description "Test package for Iter Iterator interface\377";
+
+uses
+	CtrlLib,
+	Iter;
+
+file
+	IterTest.h,
+	main.cpp,
+	IterTest.lay;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/IterTest/init
+++ b/bazaar/IterTest/init
@ -0,0 +1,5 @@
+#ifndef _IterTest_icpp_init_stub
+#define _IterTest_icpp_init_stub
+#include "CtrlLib/init"
+#include "Iter/init"
+#endif
--- a/bazaar/IterTest/main.cpp
+++ b/bazaar/IterTest/main.cpp
@ -0,0 +1,147 @@
+#include "IterTest.h"
+
+void CommonHandler(Iter<int>& ii)
+{
+	while(ii.Next())
+		ii.Get() = Random();
+}
+
+IterTest::IterTest()
+{
+	CtrlLayout(*this, "Window title");
+
+	//generally, an iter interface needs its underlying container to live as long as interface is present.
+	//no checks are performed to keep code small
+	//an Iter interface will not modify the underlying container.
+	//if container is changed while an Iter interface is bound to it, it may become undefined in behaviour (Vector i.e)
+	//an Iter interface is always created on heap, so use means to delete it after usage, best is One<Iter<int > > foo, destroyed when scope is left
+
+	//==========================================================================================	
+
+	//Vector or any common linear container	
+
+	Vector<int> vi;
+	vi.SetCount(10);
+
+	//use the explicit interface to do things
+	One<Iter<int> > ii = IterCreator::GetIter(vi);
+	while(ii->Next())
+		ii->Get() = Random();
+
+	//an iterator can be copied, without knowing its underlying type
+	//and can be reinitiated
+	One<Iter<int> > ii2 = ii->PartialCopy();
+	while(ii2->Next())
+		LOG(ii2->Get());
+
+	//the const variant of Iter, ConstIter
+	One<ConstIter<int> > ii3 = IterCreator::GetIter((const Vector<int>&)vi);
+	while(ii3->Next())
+		LOG(ii3->Get());
+
+	FOREACH(int, e, vi)
+		LOG(e);
+
+	//and the const version
+	FOREACHC(int, e, (const Vector<int>&)vi)
+		LOG(e);
+
+	//helpers to define the scope safe iterators
+	ITER(int) _ii = IterCreator::GetIter(vi);
+	ITERC(int) _cii = IterCreator::GetIter((const Vector<int>&)vi);
+
+	//a macro for usual containers only without using Iter interface
+	//can speed up things because no virtual stuff involved
+	FOREACHCONT(int, e, vi)
+		LOG(e);
+
+	//the const variant
+	FOREACHCONTC(int, e, (const Vector<int>&)vi)
+		LOG(e);
+
+	//other 'containers' also yield a Iter interface
+
+	//usual pointer
+
+	int in = 123;
+	int* inp = &in;
+
+	FOREACH(int, e, inp)
+		LOG(e);
+
+	FOREACHC(int, e, (const int*)inp)
+		LOG(e);
+
+	//Ptr
+
+	EditInt ei;
+	Ptr<Ctrl> eip(&ei);
+
+	FOREACH(Ctrl, e, eip)
+		e.SetData(123); 
+
+	FOREACHC(Ctrl, e, (const Ptr<Ctrl>&)eip)
+		e.GetData(); 
+
+	//One
+
+	One<Ctrl> oei;
+	oei.Create<EditInt>();
+
+	FOREACH(Ctrl, e, oei)
+		e.SetData(123); 
+
+	FOREACHC(Ctrl, e, (const One<Ctrl>&)oei)
+		e.GetData(); 
+
+	//Any
+
+	Any a;
+	a.Create<int>() = 345;
+	One<Iter<int> > ia = IterCreator::GetIter<int>(a);
+	
+	FOREACH(int, e, a)
+		LOG(e); 
+
+	FOREACHC(int, e, (const Any&)a)
+		LOG(e); 
+
+	//Value
+
+	Value v = 789;
+	One<Iter<int> > iv = IterCreator::GetIter<int>(v);
+
+	FOREACH(int, e, v)
+		LOG(e);
+	
+	FOREACHC(int, e, (const Value&)v)
+		LOG(e);
+
+	//Link
+
+	LinkOwner<Foo> lf;
+	for(int i = 0; i < 10; i++)
+		lf.InsertPrev()->d = i;
+
+	FOREACH(Foo, e, (Link<Foo>&)lf)
+		LOG(e.d);
+
+	FOREACHC(Foo, e, (const Link<Foo>&)lf)
+		LOG(e.d);
+
+	//all containers can be handled in a common interface	
+	ITER(int) iii;
+
+	iii = IterCreator::GetIter(vi);
+	CommonHandler(*iii);
+
+	Array<int> ai;
+	iii = IterCreator::GetIter(ai);
+	CommonHandler(*iii);	
+}
+
+GUI_APP_MAIN
+{
+	IterTest().Run();
+}
+
--- a/bazaar/LogPosCtrl/LogPosCtrl.cpp
+++ b/bazaar/LogPosCtrl/LogPosCtrl.cpp
@ -0,0 +1,317 @@
+#include "LogPosCtrl.h"
+
+static void sLay1(int& pos, int& r, int align, int a, int b, int sz)
+{
+	pos = a;
+	int size = b;
+	switch(align) {
+	case Ctrl::CENTER:
+		pos = (sz - b) / 2 + a;
+		break;
+	case Ctrl::RIGHT:
+		pos = sz - (a + b);
+		break;
+	case Ctrl::SIZE:
+		size = sz - (a + b);
+		break;
+	}
+	r = pos + max(size, 0);
+}
+
+Rect LogPosPopUp::CtrlRect(Ctrl::LogPos pos, Size sz)
+{
+	Rect r;
+	sLay1(r.left, r.right, pos.x.GetAlign(), pos.x.GetA(), pos.x.GetB(), sz.cx);
+	sLay1(r.top, r.bottom, pos.y.GetAlign(), pos.y.GetA(), pos.y.GetB(), sz.cy);
+	return r;
+}
+
+Ctrl::Logc MakeLogc(int align, int a, int b, int sz)
+{
+	int isz = b - a;
+	switch(align) {
+	case Ctrl::LEFT:
+		return Ctrl::PosLeft(a, isz);
+	case Ctrl::RIGHT:
+		return Ctrl::PosRight(sz - b, isz);
+	case Ctrl::CENTER:
+		return Ctrl::PosCenter(isz, a - (sz - isz) / 2);
+	}
+	return Ctrl::PosSize(a, sz - b);
+}
+
+Ctrl::LogPos LogPosPopUp::MakeLogPos(int ax, int ay, const Rect& r, Size sz)
+{
+	return Ctrl::LogPos(MakeLogc(ax, r.left, r.right, sz.cx),
+	                    MakeLogc(ay, r.top, r.bottom, sz.cy));
+}
+
+Ctrl::LogPos LogPosPopUp::MakeLogPos(Ctrl::LogPos p, const Rect& r, Size sz)
+{
+	return MakeLogPos(p.x.GetAlign(), p.y.GetAlign(), r, sz);
+}
+
+Ctrl::LogPos LogPosPopUp::ReAlign(const Ctrl& c, const Ctrl::LogPos& npos)
+{
+	if(!c.GetParent()) return npos;
+	//convert ctrl's pos to its rect in parent
+	//and reconvert to logpos using new align
+	Size sz = c.GetParent()->GetSize();
+	Ctrl::LogPos pos = c.GetPos();
+	Rect r = CtrlRect(pos, sz);
+	pos = MakeLogPos(npos, r, sz);
+	return pos;
+}
+
+void LogPosPopUp::Set(const Ctrl::LogPos& p)
+{
+	pos = p;	
+	xa <<= pos.x.GetA(); xb <<= pos.x.GetB();
+	switch(pos.x.GetAlign())
+	{
+		case Ctrl::LEFT:   l <<= true;  r <<= false; break;
+		case Ctrl::RIGHT:  l <<= false; r <<= true; break;
+		case Ctrl::SIZE:   l <<= true;  r <<= true; break;
+		default:
+		case Ctrl::CENTER: l <<= false; r <<= false; break;
+	}
+	ya <<= pos.y.GetA(); yb <<= pos.y.GetB();
+	switch(pos.y.GetAlign())
+	{
+		case Ctrl::TOP: u    <<= true;  d <<= false; break;
+		case Ctrl::BOTTOM: u <<= false; d <<= true;  break;
+		case Ctrl::SIZE: u   <<= true;  d <<= true;  break;
+		default:
+		case Ctrl::CENTER: u <<= false; d <<= false; break;
+	}
+}
+
+void LogPosPopUp::Updated()
+{
+	switch(pos.x.GetAlign())
+	{
+		case Ctrl::LEFT:   sxa.SetText("Marg L"); sxb.SetText("Size"); sxn.SetText("Left"); break;
+		case Ctrl::RIGHT:  sxa.SetText("Marg R"); sxb.SetText("Size"); sxn.SetText("Right"); break;
+		case Ctrl::SIZE:   sxa.SetText("Marg L"); sxb.SetText("Marg R"); sxn.SetText("HFill"); break;
+		default:
+		case Ctrl::CENTER: sxa.SetText("Offs");   sxb.SetText("Size"); sxn.SetText("HCenter"); break;
+	}
+	switch(pos.y.GetAlign())
+	{
+		case Ctrl::TOP:    sya.SetText("Marg U"); syb.SetText("Size"); syn.SetText("Top"); break;
+		case Ctrl::BOTTOM: sya.SetText("Marg D"); syb.SetText("Size"); syn.SetText("Bottom"); break;
+		case Ctrl::SIZE:   sya.SetText("Marg U"); syb.SetText("Marg D"); syn.SetText("VFill"); break;
+		default:
+		case Ctrl::CENTER: sya.SetText("Offs");   syb.SetText("Size"); syn.SetText("VCenter"); break;
+	}
+}
+
+//obsolete
+Ctrl::LogPos LogPosPopUp::Generate() const
+{
+	Ctrl::LogPos pos;
+	int q;
+
+	q = 0;
+	q |= ((l)?(1):(0));
+	q |= ((r)?(2):(0));
+	switch(q)
+	{
+		case 1: pos.x.SetAlign(Ctrl::LEFT); break;
+		case 2: pos.x.SetAlign(Ctrl::RIGHT); break;
+		case 3: pos.x.SetAlign(Ctrl::SIZE); break;
+		default:
+		case 0: pos.x.SetAlign(Ctrl::CENTER); break;
+	}
+	pos.x.SetA(xa); pos.x.SetB(xb);
+
+	q = 0;
+	q |= ((u)?(1):(0));
+	q |= ((d)?(2):(0));
+	switch(q)
+	{
+		case 1: pos.y.SetAlign(Ctrl::TOP); break;
+		case 2: pos.y.SetAlign(Ctrl::BOTTOM); break;
+		case 3: pos.y.SetAlign(Ctrl::SIZE); break;
+		default:
+		case 0: pos.y.SetAlign(Ctrl::CENTER); break;
+	}
+	pos.y.SetA(ya); pos.y.SetB(yb);
+
+	return pos; 
+}
+
+void LogPosPopUp::XaCB()
+{
+	pos.x.SetA(xa);
+	WhenSizeChange();
+	UpdateAction();
+}
+void LogPosPopUp::XbCB()
+{
+	pos.x.SetB(xb);
+	WhenSizeChange();
+	UpdateAction();
+}
+void LogPosPopUp::YaCB()
+{
+	pos.y.SetA(ya);
+	WhenSizeChange();
+	UpdateAction();
+}
+void LogPosPopUp::YbCB()
+{
+	pos.y.SetB(yb);
+	WhenSizeChange();
+	UpdateAction();
+}
+void LogPosPopUp::XAlignCB()
+{
+	int q = 0;
+	q |= ((l)?(1):(0));
+	q |= ((r)?(2):(0));
+	switch(q)
+	{
+		case 1: pos.x.SetAlign(Ctrl::LEFT); break;
+		case 2: pos.x.SetAlign(Ctrl::RIGHT); break;
+		case 3: pos.x.SetAlign(Ctrl::SIZE); break;
+		default:
+		case 0: pos.x.SetAlign(Ctrl::CENTER); break;
+	}
+	WhenAlignChange();
+	UpdateAction();
+}
+void LogPosPopUp::YAlignCB()
+{
+	int q = 0;
+	q |= ((u)?(1):(0));
+	q |= ((d)?(2):(0));
+	switch(q)
+	{
+		case 1: pos.y.SetAlign(Ctrl::TOP); break;
+		case 2: pos.y.SetAlign(Ctrl::BOTTOM); break;
+		case 3: pos.y.SetAlign(Ctrl::SIZE); break;
+		default:
+		case 0: pos.y.SetAlign(Ctrl::CENTER); break;
+	}
+	WhenAlignChange();
+	UpdateAction();
+}
+
+LogPosPopUp::LogPosPopUp()
+{
+	CtrlLayout(*this);
+	SetFrame(BlackFrame());
+
+	l.SetLabel("<");
+	r.SetLabel(">");
+	u.SetLabel("/\\");
+	d.SetLabel("\\/");
+	
+	xa <<= THISBACK(XaCB);
+	xb <<= THISBACK(XbCB);
+	ya <<= THISBACK(YaCB);
+	yb <<= THISBACK(YbCB);
+
+	l <<= THISBACK(XAlignCB);
+	r <<= THISBACK(XAlignCB);
+	u <<= THISBACK(YAlignCB);
+	d <<= THISBACK(YAlignCB);
+	
+	ok <<= THISBACK(Acceptor);
+	cancel <<= THISBACK(Rejector);
+}
+
+NAMESPACE_UPP
+template<>
+String AsString(const Ctrl::LogPos& pos)
+{
+	String s;
+	int xa = pos.x.GetA(), xb = pos.x.GetB();
+	switch(pos.x.GetAlign())
+	{
+		case Ctrl::LEFT:   s << "Left(mr:" << xa << ",sz:" << xb << ")"; break;
+		case Ctrl::RIGHT:  s << "Right(mr:" << xa << ",sz:" << xb << ")"; break;
+		case Ctrl::SIZE:   s << "HSize(mr:" << xa << ",mr:" << xb << ")"; break;
+		default:
+		case Ctrl::CENTER: s << "HCent(of:" << xa << ",sz:" << xb << ")"; break;
+	}
+	s << ".";
+	int ya = pos.y.GetA(), yb = pos.y.GetB();
+	switch(pos.y.GetAlign())
+	{
+		case Ctrl::TOP:    s << "Top(mr:" << ya << ",sz:" << yb << ")"; break;
+		case Ctrl::BOTTOM: s << "Bottom(mr:" << ya << ",sz:" << yb << ")"; break;
+		case Ctrl::SIZE:   s << "VSize(mr:" << ya << ",mr:" << yb << ")"; break;
+		default:
+		case Ctrl::CENTER: s << "VCent(of:" << ya << ",sz:" << yb << ")"; break;
+	}
+	return s;
+}
+END_UPP_NAMESPACE
+
+LogPosCtrl::LogPosCtrl() : push(false)
+{
+	IgnoreMouse(false);
+
+	lc.WhenSelect = THISBACK(AcceptDrop);
+	lc.WhenCancel = THISBACK(CloseDrop);
+	lc.WhenAction = THISBACK(ActionDrop);
+	
+	lc.WhenSizeChange = THISBACK(OnSizeChange);
+	lc.WhenAlignChange = THISBACK(OnAlignChange);
+}
+
+void LogPosCtrl::LeftDown(Point p, dword keyflags)
+{
+	if(!HasFocus()) SetFocus();
+	Drop();	
+}
+
+void LogPosCtrl::Drop()
+{
+	if(push) return;
+	push = true;
+	savedpos = pos;
+	lc.PopUp(this, pos);
+}
+
+void LogPosCtrl::CloseDrop()
+{
+	push = false;
+	if(pos != savedpos) {
+		pos = savedpos;
+		OnSizeChange(); //restore
+		UpdateAction();
+	}
+}
+
+void LogPosCtrl::AcceptDrop()
+{
+	push = false;
+	pos = lc.Get();
+	UpdateAction();
+}
+
+void LogPosCtrl::ActionDrop()
+{
+	pos = lc.Get();
+	UpdateAction();
+}
+
+void LogPosCtrl::Updated()
+{
+	SetText(AsString(pos));
+}
+
+void LogPosCtrl::OnSizeChange()
+{
+	if(!posparent) return;
+}
+
+void LogPosCtrl::OnAlignChange()
+{
+	if(!posparent) return;
+	lc.Set(LogPosPopUp::ReAlign(*posparent, lc.Get()));
+	lc.Update(); //feedback to lc
+}
--- a/bazaar/LogPosCtrl/LogPosCtrl.h
+++ b/bazaar/LogPosCtrl/LogPosCtrl.h
@ -0,0 +1,85 @@
+#ifndef _LogPosCtrl_LogPosCtrl_h
+#define _LogPosCtrl_LogPosCtrl_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define LAYOUTFILE <LogPosCtrl/LogPosPopUp.lay>
+#include <CtrlCore/lay.h>
+
+#include <PopUpC/PopUpC.h>
+
+const dword LOGPOS_V    = 20;
+NAMESPACE_UPP
+template<> inline dword ValueTypeNo(const Ctrl::LogPos*)    { return LOGPOS_V; }
+END_UPP_NAMESPACE
+
+class LogPosPopUp : public WithLogPosPopUpLayout<PopUpC> {
+public:
+	typedef LogPosPopUp CLASSNAME;
+	LogPosPopUp();
+	
+	static Rect CtrlRect(Ctrl::LogPos pos, Size sz);
+	static Ctrl::LogPos MakeLogPos(int ax, int ay, const Rect& r, Size sz);
+	static Ctrl::LogPos MakeLogPos(Ctrl::LogPos p, const Rect& r, Size sz);
+	static Ctrl::LogPos ReAlign(const Ctrl& c, const Ctrl::LogPos& npos);
+
+	virtual void Updated();
+	virtual Value GetData() const { return RawToValue(pos); }
+	virtual void SetData(const Value& v) { if(!v.Is<Ctrl::LogPos>()) return; Set(RawValue<Ctrl::LogPos>::Extract(v)); Update(); }
+
+	Ctrl::LogPos Generate() const; 	//obsolete
+	Ctrl::LogPos Get() const { return pos; }
+	void Set(const Ctrl::LogPos& p);
+	void PopUp(Ctrl* owner, const Ctrl::LogPos& p) { Set(p); Update(); PopUpC::PopUp(owner); }
+
+	Callback WhenSizeChange;
+	Callback WhenAlignChange;
+	
+protected:
+	void XaCB();
+	void XbCB();
+	void YaCB();
+	void YbCB();
+	void XAlignCB();
+	void YAlignCB();
+
+	Ctrl::LogPos pos;
+};
+
+NAMESPACE_UPP
+template<> String AsString(const Ctrl::LogPos& pos);
+END_UPP_NAMESPACE
+
+class LogPosCtrl : public StaticText
+{
+public:
+	typedef LogPosCtrl CLASSNAME;
+	LogPosCtrl();
+
+	virtual void LeftDown(Point p, dword keyflags);
+	virtual void Updated();
+	virtual Value GetData() const { return RawToValue(pos); }
+	virtual void SetData(const Value& v) { if(!v.Is<Ctrl::LogPos>()) return; pos = RawValue<Ctrl::LogPos>::Extract(v); Update(); }
+
+	Ctrl::LogPos Get() const { return pos; }
+	void Set(const Ctrl::LogPos& p) { pos = p; Update(); }
+	void Set(Ctrl& c) { posparent = &c; pos = c.GetPos(); Update(); }
+	void Drop();
+	
+protected:
+	void CloseDrop();
+	void AcceptDrop();
+	void ActionDrop();
+	void OnSizeChange();
+	void OnAlignChange();
+
+	Ctrl::LogPos pos, savedpos;
+	bool push;
+	LogPosPopUp lc;
+	Ptr<Ctrl> posparent;
+};
+
+#endif
+
--- a/bazaar/LogPosCtrl/LogPosCtrl.lay
+++ b/bazaar/LogPosCtrl/LogPosCtrl.lay
@ -0,0 +1,21 @@
+LAYOUT(LogPosCtrlLayout, 232, 120)
+	ITEM(ButtonOption, l, LeftPosZ(0, 20).TopPosZ(20, 60))
+	ITEM(ButtonOption, r, LeftPosZ(80, 20).TopPosZ(20, 60))
+	ITEM(ButtonOption, u, LeftPosZ(20, 60).TopPosZ(0, 20))
+	ITEM(ButtonOption, d, LeftPosZ(20, 60).TopPosZ(80, 20))
+	ITEM(StaticText, sxn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(28, 19))
+	ITEM(StaticText, syn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(52, 19))
+	ITEM(StaticText, sxa, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(8, 19))
+	ITEM(EditIntSpin, xa, NotNull(true).LeftPosZ(108, 60).TopPosZ(28, 20))
+	ITEM(StaticText, sxb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(8, 19))
+	ITEM(EditIntSpin, xb, NotNull(true).LeftPosZ(172, 60).TopPosZ(28, 20))
+	ITEM(StaticText, sya, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(52, 19))
+	ITEM(EditIntSpin, ya, NotNull(true).LeftPosZ(108, 60).TopPosZ(72, 20))
+	ITEM(StaticText, syb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(52, 19))
+	ITEM(EditIntSpin, yb, NotNull(true).LeftPosZ(172, 60).TopPosZ(72, 20))
+	ITEM(Button, ok, SetLabel(t_("OK")).LeftPosZ(120, 56).TopPosZ(100, 19))
+	ITEM(Button, cancel, SetLabel(t_("Cancel")).LeftPosZ(176, 56).TopPosZ(100, 19))
+	ITEM(StaticText, dv___16, SetText(t_("X:")).LeftPosZ(108, 12).TopPosZ(8, 19))
+	ITEM(StaticText, dv___17, SetText(t_("Y:")).LeftPosZ(108, 12).TopPosZ(52, 19))
+END_LAYOUT
+
--- a/bazaar/LogPosCtrl/LogPosCtrl.upp
+++ b/bazaar/LogPosCtrl/LogPosCtrl.upp
@ -0,0 +1,11 @@
+description "Editing Ctrl::LogPos\377";
+
+uses
+	CtrlLib,
+	PopUpC;
+
+file
+	LogPosPopUp.lay,
+	LogPosCtrl.h,
+	LogPosCtrl.cpp;
+
--- a/bazaar/LogPosCtrl/LogPosPopUp.lay
+++ b/bazaar/LogPosCtrl/LogPosPopUp.lay
@ -0,0 +1,21 @@
+LAYOUT(LogPosPopUpLayout, 232, 120)
+	ITEM(ButtonOption, l, LeftPosZ(0, 20).TopPosZ(20, 60))
+	ITEM(ButtonOption, r, LeftPosZ(80, 20).TopPosZ(20, 60))
+	ITEM(ButtonOption, u, LeftPosZ(20, 60).TopPosZ(0, 20))
+	ITEM(ButtonOption, d, LeftPosZ(20, 60).TopPosZ(80, 20))
+	ITEM(StaticText, sxn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(28, 19))
+	ITEM(StaticText, syn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(52, 19))
+	ITEM(StaticText, sxa, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(8, 19))
+	ITEM(EditIntSpin, xa, NotNull(true).LeftPosZ(108, 60).TopPosZ(28, 20))
+	ITEM(StaticText, sxb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(8, 19))
+	ITEM(EditIntSpin, xb, NotNull(true).LeftPosZ(172, 60).TopPosZ(28, 20))
+	ITEM(StaticText, sya, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(52, 19))
+	ITEM(EditIntSpin, ya, NotNull(true).LeftPosZ(108, 60).TopPosZ(72, 20))
+	ITEM(StaticText, syb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(52, 19))
+	ITEM(EditIntSpin, yb, NotNull(true).LeftPosZ(172, 60).TopPosZ(72, 20))
+	ITEM(Button, ok, SetLabel(t_("OK")).LeftPosZ(120, 56).TopPosZ(100, 19))
+	ITEM(Button, cancel, SetLabel(t_("Cancel")).LeftPosZ(176, 56).TopPosZ(100, 19))
+	ITEM(StaticText, dv___16, SetText(t_("X:")).LeftPosZ(108, 12).TopPosZ(8, 19))
+	ITEM(StaticText, dv___17, SetText(t_("Y:")).LeftPosZ(108, 12).TopPosZ(52, 19))
+END_LAYOUT
+
--- a/bazaar/LogPosCtrl/init
+++ b/bazaar/LogPosCtrl/init
@ -0,0 +1,5 @@
+#ifndef _LogPosCtrl_icpp_init_stub
+#define _LogPosCtrl_icpp_init_stub
+#include "CtrlLib/init"
+#include "PopUpC/init"
+#endif
--- a/bazaar/LogPosCtrlTest/LogPosCtrlTest.h
+++ b/bazaar/LogPosCtrlTest/LogPosCtrlTest.h
@ -0,0 +1,26 @@
+#ifndef _LogPosCtrlTest_LogPosCtrlTest_h
+#define _LogPosCtrlTest_LogPosCtrlTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#include <LogPosCtrl/LogPosCtrl.h>
+
+#define LAYOUTFILE <LogPosCtrlTest/LogPosCtrlTest.lay>
+#include <CtrlCore/lay.h>
+
+#include <LogPosCtrl/LogPosCtrl.h>
+
+class LogPosCtrlTest : public WithLogPosCtrlTestLayout<TopWindow> {
+public:
+	typedef LogPosCtrlTest CLASSNAME;
+	LogPosCtrlTest();
+	
+	void ChangeLogPosCB();
+
+	LogPosCtrl le;
+};
+
+#endif
+
--- a/bazaar/LogPosCtrlTest/LogPosCtrlTest.lay
+++ b/bazaar/LogPosCtrlTest/LogPosCtrlTest.lay
@ -0,0 +1,8 @@
+LAYOUT(LogPosCtrlTestLayout, 492, 196)
+	ITEM(ArrayCtrl, ac, LeftPosZ(8, 190).TopPosZ(8, 96))
+END_LAYOUT
+
+LAYOUT(LogPosCtrlDlg, 400, 200)
+	ITEM(Button, ok, SetLabel(t_("OK")).HCenterPosZ(56, 0).BottomPosZ(5, 19))
+END_LAYOUT
+
--- a/bazaar/LogPosCtrlTest/LogPosCtrlTest.upp
+++ b/bazaar/LogPosCtrlTest/LogPosCtrlTest.upp
@ -0,0 +1,14 @@
+description "Editing Ctrl::LogPos\377";
+
+uses
+	CtrlLib,
+	LogPosCtrl;
+
+file
+	LogPosCtrlTest.h,
+	main.cpp,
+	LogPosCtrlTest.lay;
+
+mainconfig
+	"" = "GUI";
+
--- a/bazaar/LogPosCtrlTest/main.cpp
+++ b/bazaar/LogPosCtrlTest/main.cpp
@ -0,0 +1,25 @@
+#include "LogPosCtrlTest.h"
+
+void LogPosCtrlTest::ChangeLogPosCB()
+{
+	ac.SetPos(le.Get());	
+}
+
+LogPosCtrlTest::LogPosCtrlTest()
+{
+	CtrlLayout(*this, "Window title");
+	Sizeable().Zoomable();
+
+	Add(le.LeftPos(10, 200).BottomPos(10, 20));
+	le <<= THISBACK(ChangeLogPosCB);
+
+	//init
+	Ctrl& c = ac;	
+	le.Set(c); 
+}
+
+GUI_APP_MAIN
+{
+	LogPosCtrlTest().Run();
+}
+
--- a/bazaar/PointCtrl/PointCtrl.cpp
+++ b/bazaar/PointCtrl/PointCtrl.cpp
@ -0,0 +1,159 @@
+#include "PointCtrl.h"
+
+CH_STYLE(PointCtrl, Style, StyleDefault)
+{
+	backcol = SColorPaper();
+	linecol = Blue();
+	pointcol = LtRed();
+	linesize = 1;
+	pointsize = 4;
+}
+
+PointCtrl::PointCtrl()
+	: pressed(false), moving(false), di(-1)
+{
+	style = &StyleDefault();
+	sxp.Clear();
+	xp.SetNull();
+
+	vsx.MinMax(0,100);
+	vsy.MinMax(0,100);
+
+	for(int i = 0; i < 10; i++)
+		vpd.Add().col = HsvColorf(i/(double)10, 1.0, 1.0);
+	
+	Update();
+}
+
+void PointCtrl::Paint(Draw& w)
+{
+	w.DrawRect(sz, style->backcol);
+
+	//points
+	for(int i = 0; i < vp.GetCount(); i++)
+	{
+		const XY& _dp = vp[i];
+		XY _p((int) psx(vsx, _dp.x), (int) psy(vsy, _dp.y));
+		const PData& pd = vpd.At(i);
+		Rect r(_p,_p); r.Inflate(pd.size);
+		w.DrawEllipse(r, pd.col);
+	}
+
+	//cross
+	if(!xp.IsNullInstance()) 
+	{
+		w.DrawLine(xp.x-3,xp.y, xp.x+3+1,xp.y, style->linesize, style->linecol);
+		w.DrawLine(xp.x,xp.y-3, xp.x,xp.y+3+1, style->linesize, style->linecol);
+
+		//target lines
+		if(pressed && moving) 
+		{
+			w.DrawLine(0,xp.y, sz.cx,xp.y, style->linesize, style->linecol);
+			w.DrawLine(xp.x,0, xp.x,sz.cy, style->linesize, style->linecol);
+		}
+	}
+
+	//square
+	Rect r(sxp, sxp); r.Inflate(style->pointsize);
+	Vector<Point> vp;
+	vp << r.TopLeft() << r.TopRight() << r.BottomRight() << r.BottomLeft() << r.TopLeft();
+	w.DrawPolyline(vp, style->linesize, style->pointcol);
+
+	//dot
+	w.DrawLine(sxp.x, sxp.y, sxp.x, sxp.y, 2, style->pointcol);
+}
+
+void PointCtrl::LeftDown(Point p, dword keyflags)
+{
+	SetCapture();
+	moving = false;
+	pressed = (keyflags & K_MOUSELEFT);
+
+	xp = p;
+	sxp = xp;
+
+	//point drag
+	for(int i = 0; i < vp.GetCount(); i++)
+	{
+		XY& _dp = vp[i];
+		Point _p(int(psx(vsx, _dp.x)), int(psy(vsy, _dp.y)));
+		Rect r(_p, _p); r.Inflate(4);
+		if(!r.Contains(p)) continue;
+		di = i; break;
+	}
+	UpdateActionRefresh();
+}
+
+void PointCtrl::LeftRepeat(Point p, dword keyflags)
+{
+	if(moving) return;
+	
+	if(di<0 && !(keyflags & K_CTRL))
+	{
+		di = vp.GetCount();
+		XY& _dp = vp.Add(XY(vsx(psx, sxp.x), vsy(psy, sxp.y)));
+		WhenAddPoint();
+	}
+	else if(di>=0 && (keyflags & K_CTRL))
+	{
+		vp.Remove(di);
+		WhenRemovePoint(di);
+		di = -1;
+		moving = true;
+	}
+	else return;
+	
+	Refresh();
+}
+
+void PointCtrl::MouseMove(Point p, dword keyflags)
+{
+	moving = true;
+	pressed = (keyflags & K_MOUSELEFT);
+
+	//clip
+	Point pp(minmax(p.x, 0, sz.cx), minmax(p.y, 0, sz.cy));
+	if(xp == pp) return;
+	xp = pp; 
+
+	if(pressed) 
+	{
+		sxp = xp;
+		if(di>=0)
+		{
+			vp[di] = XY(vsx(psx, sxp.x), vsy(psy, sxp.y));
+			WhenMovePoint(di);
+		}
+		UpdateActionRefresh();
+	}
+	else Refresh();
+}
+
+void PointCtrl::LeftUp(Point p, dword keyflags)
+{
+	ReleaseCapture();
+	pressed = false;
+	moving = false;
+	di = -1;
+	xp.SetNull();
+	Refresh();
+}
+
+void PointCtrl::Layout()
+{
+	sz = GetSize();
+	psx.MinMax(0, sz.cx);
+	psy.MinMax(0, sz.cy);
+	UpdatedBack();
+	Refresh();
+}
+
+void PointCtrl::Updated()
+{
+	vxp = XY(vsx(psx, sxp.x), vsy(psy, sxp.y));
+}
+
+void PointCtrl::UpdatedBack()
+{
+	sxp = Point(int(psx(vsx, vxp.x)), int(psy(vsy, vxp.y)));
+}
--- a/bazaar/PointCtrl/PointCtrl.h
+++ b/bazaar/PointCtrl/PointCtrl.h
@ -0,0 +1,89 @@
+#ifndef _PointCtrl_PointCtrl_h
+#define _PointCtrl_PointCtrl_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#include <Scaler/Scaler.h>
+
+typedef Pointf XY;
+
+class PointCtrl : public Ctrl {
+public:
+	typedef PointCtrl CLASSNAME;
+	PointCtrl();
+
+	struct Style : public ChStyle<Style> {
+		Color backcol;
+		Color linecol;
+		Color pointcol;
+		int linesize;
+		int pointsize;
+	};
+
+	virtual void Paint(Draw& w);
+	virtual void LeftDown(Point p, dword keyflags);
+	virtual void LeftRepeat(Point p, dword keyflags);
+	virtual void MouseMove(Point p, dword keyflags);
+	virtual void LeftUp(Point p, dword keyflags);
+	virtual void MouseEnter(Point p, dword keyflags) { xp = p; }
+	virtual void MouseLeave() { xp.SetNull(); Refresh(); }
+	
+	virtual void Updated(); //from draw domain to value domain
+	virtual void UpdatedBack(); //from value domain to draw domain
+	virtual void Layout();
+
+	static const Style& StyleDefault();
+	void SetStyle(const Style& s) { style = &s; Refresh(); }
+
+	virtual void SetData(const Value& v) { if(!v.Is<XY>()) return; vxp = v; UpdatedBack(); Refresh(); }
+	virtual Value GetData() const { return vxp; }
+
+	void SetDataX(double v) { vxp.x = minmax(v, vsx.Min(), vsx.Max()); UpdatedBack(); Refresh(); }
+	void SetDataY(double v) { vxp.y = minmax(v, vsy.Min(), vsy.Max()); UpdatedBack(); Refresh(); }
+	void SetDataXY(double vx, double vy) { vxp.x = minmax(vx, vsx.Min(), vsx.Max()); vxp.y = minmax(vy, vsy.Min(), vsy.Max()); UpdatedBack(); Refresh(); }
+	double GetDataX() const { return vxp.x; }
+	double GetDataY() const { return vxp.y; }
+	
+	void SetMinMaxX(double mn, double mx) { vsx.MinMax(mn, mx); vxp.x = minmax(vxp.x, vsx.Min(), vsx.Max()); UpdatedBack(); }
+	void SetMinMaxY(double mn, double mx) { vsy.MinMax(mn, mx);  vxp.y = minmax(vxp.y, vsy.Min(), vsy.Max()); UpdatedBack(); }
+	void SetMinMaxXY(double mnx, double mxx, double mny, double mxy) { vsx.MinMax(mnx, mxx); vsy.MinMax(mny, mxy); vxp.x = minmax(vxp.x, vsx.Min(), vsx.Max()); vxp.y = minmax(vxp.y, vsy.Min(), vsy.Max()); UpdatedBack(); }
+	double GetMinX() const { return vsx.Min(); }
+	double GetMaxX() const { return vsx.Max(); }
+	double GetMinY() const { return vsy.Min(); }
+	double GetMaxY() const { return vsy.Max(); }
+
+	struct PData : Moveable<PData>
+	{
+		String name;
+		Color col;
+		int size;
+		int shape;
+		PData() : col(LtGreen()), size(4), shape(0) {}
+	};
+
+	Vector<XY> vp;
+	Vector<PData> vpd;
+	
+	Callback WhenAddPoint;
+	Callback1<int> WhenRemovePoint;
+	Callback1<int> WhenMovePoint;
+	
+private:
+	//cache helper
+	Size sz;
+	Point xp; //when moving
+	Point sxp; //drawing representation of valx
+	bool pressed;
+	bool moving;
+	int di; //dragging point index
+
+	//vital
+	XY vxp;
+	Scaler<double> vsx, psx, vsy, psy;
+	const Style* style;
+};
+
+#endif
+
--- a/bazaar/PointCtrl/PointCtrl.upp
+++ b/bazaar/PointCtrl/PointCtrl.upp
@ -0,0 +1,10 @@
+description "Point placement Ctrl\377";
+
+uses
+	CtrlLib,
+	Scaler;
+
+file
+	PointCtrl.h,
+	PointCtrl.cpp;
+
--- a/bazaar/PointCtrl/init
+++ b/bazaar/PointCtrl/init
@ -0,0 +1,5 @@
+#ifndef _PointCtrl_icpp_init_stub
+#define _PointCtrl_icpp_init_stub
+#include "CtrlLib/init"
+#include "Scaler/init"
+#endif
--- a/bazaar/PointCtrlTest/PointCtrlTest.h
+++ b/bazaar/PointCtrlTest/PointCtrlTest.h
@ -0,0 +1,29 @@
+#ifndef _PointCtrlTest_PointCtrlTest_h
+#define _PointCtrlTest_PointCtrlTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#include <PointCtrl/PointCtrl.h>
+
+#define LAYOUTFILE <PointCtrlTest/PointCtrlTest.lay>
+#include <CtrlCore/lay.h>
+
+class PointCtrlTest : public WithPointCtrlTestLayout<TopWindow> {
+public:
+	typedef PointCtrlTest CLASSNAME;
+	PointCtrlTest();
+
+	void ToInfo(const String& s) { info.Insert(info.GetLength(), s + "\n"); info.SetCursor(info.GetLength()); }
+	void PosCB();
+	void SlXCB();
+	void SlYCB();
+	
+	void OnAddPoint();
+	void OnRemovePoint(int i);
+	void OnMovePoint(int i);
+};
+
+#endif
+
--- a/bazaar/PointCtrlTest/PointCtrlTest.lay
+++ b/bazaar/PointCtrlTest/PointCtrlTest.lay
@ -0,0 +1,7 @@
+LAYOUT(PointCtrlTestLayout, 600, 300)
+	ITEM(DocEdit, info, RightPosZ(0, 292).VSizePosZ(0, 0))
+	ITEM(SliderCtrl, slx, HSizePosZ(0, 328).BottomPosZ(0, 24))
+	ITEM(SliderCtrl, sly, RightPosZ(296, 28).VSizePosZ(0, 28))
+	ITEM(PointCtrl, pc, HSizePosZ(0, 324).VSizePosZ(0, 24))
+END_LAYOUT
+
--- a/bazaar/PointCtrlTest/PointCtrlTest.upp
+++ b/bazaar/PointCtrlTest/PointCtrlTest.upp
@ -0,0 +1,14 @@
+description "PointCtrl Test package, a Point placement Ctrl\377";
+
+uses
+	CtrlLib,
+	PointCtrl;
+
+file
+	PointCtrlTest.h,
+	main.cpp,
+	PointCtrlTest.lay;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/PointCtrlTest/init
+++ b/bazaar/PointCtrlTest/init
@ -0,0 +1,5 @@
+#ifndef _PointCtrlTest_icpp_init_stub
+#define _PointCtrlTest_icpp_init_stub
+#include "CtrlLib/init"
+#include "PointCtrl/init"
+#endif
--- a/bazaar/PointCtrlTest/main.cpp
+++ b/bazaar/PointCtrlTest/main.cpp
@ -0,0 +1,63 @@
+#include "PointCtrlTest.h"
+
+PointCtrlTest::PointCtrlTest()
+{
+	CtrlLayout(*this, "Window title");
+	Sizeable().Zoomable();
+
+	pc.SetMinMaxXY(0,100,0,100);
+	pc <<= THISBACK(PosCB);
+
+	pc.WhenAddPoint = THISBACK(OnAddPoint);
+	pc.WhenRemovePoint = THISBACK(OnRemovePoint);
+	pc.WhenMovePoint = THISBACK(OnMovePoint);
+
+	slx.MinMax(0,100);
+	slx <<= THISBACK(SlXCB);
+	sly.MinMax(0,100);
+	sly <<= THISBACK(SlYCB);
+	
+	PointCtrl();
+}
+
+void PointCtrlTest::SlXCB()
+{
+	pc.SetDataX(slx.GetData());
+	PosCB(); //show
+}
+
+void PointCtrlTest::SlYCB()
+{
+	pc.SetDataY(sly.GetData());
+	PosCB(); //show
+}
+
+void PointCtrlTest::PosCB()
+{
+	double x = pc.GetDataX();
+	double y = pc.GetDataY();
+	slx.SetData(x);
+	sly.SetData(y);
+	ToInfo(String().Cat() << "(" << x << "," << y << ")");
+}
+
+void PointCtrlTest::OnAddPoint()
+{
+	ToInfo(String().Cat() << "Added: XY(" << pc.vp.Top() << ")");
+}
+
+void PointCtrlTest::OnRemovePoint(int i)
+{
+	ToInfo(String().Cat() << "Removed Point @: " << i);
+}
+
+void PointCtrlTest::OnMovePoint(int i)
+{
+	ToInfo(String().Cat() << "MovePoint @: " << i << " XY(" << pc.vp[i] << ")");
+}
+
+GUI_APP_MAIN
+{
+	PointCtrlTest().Run();
+}
+
--- a/bazaar/PopUpC/PopUpC.cpp
+++ b/bazaar/PopUpC/PopUpC.cpp
@ -0,0 +1,57 @@
+#include "PopUpC.h"
+
+void PopUpC::Deactivate() {
+	if(IsOpen()) {
+		IgnoreMouseClick();
+		Rejector();
+	}
+}
+
+void PopUpC::Acceptor()
+{
+	if(Accept())
+	{
+		Close();
+		WhenSelect();
+	}
+}
+
+void PopUpC::Rejector()
+{
+	Reject();
+	Close();
+	WhenCancel();
+}
+
+
+void PopUpC::PopUp(Ctrl* owner)
+{
+	Size sz = AddFrameSize(GetSize());
+	Rect wr = GetWorkArea();
+	Rect r = owner->GetScreenRect();
+	int x = r.left;
+	int y = r.bottom;
+	if(x + sz.cx >= wr.right)
+		x = r.right - sz.cx;
+	if(y + sz.cy >= wr.bottom)
+		y = r.top - sz.cy;
+
+	Rect rt = RectC(x, y, sz.cx, sz.cy);
+	if(GUI_PopUpEffect()) {
+		sPaintRedirectCtrl pb;
+		pb.ctrl = this;
+		Add(pb.BottomPos(0, rt.Height()).LeftPos(0, rt.Width()));
+		SetRect(RectC(rt.left, rt.top, 1, 1));
+		Ctrl::PopUp(owner, true, true, GUI_GlobalStyle() >= GUISTYLE_XP);
+		SetFocus();
+		Ctrl::ProcessEvents();
+		Animate(*this, rt, GUIEFFECT_SLIDE);
+		pb.Remove();
+	}
+	else {
+		SetRect(rt);
+		Ctrl::PopUp(owner, true, true, true);
+	}
+	SetFocus();
+}
+
--- a/bazaar/PopUpC/PopUpC.h
+++ b/bazaar/PopUpC/PopUpC.h
@ -0,0 +1,23 @@
+#ifndef _PopUpC_PopUpC_h
+#define _PopUpC_PopUpC_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+class PopUpC : public StaticRect
+{
+public:
+	typedef PopUpC CLASSNAME;
+
+	virtual void Acceptor();
+	virtual void Rejector();
+	virtual void PopUp(Ctrl* owner);
+	virtual void Deactivate();
+
+	Callback WhenSelect;
+	Callback WhenCancel;
+};
+
+#endif
+
--- a/bazaar/PopUpC/PopUpC.upp
+++ b/bazaar/PopUpC/PopUpC.upp
@ -0,0 +1,9 @@
+description "PopUpC Ctrl, common class for using PopUps\377";
+
+uses
+	CtrlLib;
+
+file
+	PopUpC.h,
+	PopUpC.cpp;
+
--- a/bazaar/PopUpC/init
+++ b/bazaar/PopUpC/init
@ -0,0 +1,4 @@
+#ifndef _PopUpC_icpp_init_stub
+#define _PopUpC_icpp_init_stub
+#include "CtrlLib/init"
+#endif
--- a/bazaar/PopUpTest/PopUpTest.h
+++ b/bazaar/PopUpTest/PopUpTest.h
@ -0,0 +1,26 @@
+#ifndef _PopUpTest_PopUpTest_h
+#define _PopUpTest_PopUpTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#include <PopUpC/PopUpC.h>
+
+#define LAYOUTFILE <PopUpTest/PopUpTest.lay>
+#include <CtrlCore/lay.h>
+
+class PopUpTest : public WithPopUpTestLayout<TopWindow> {
+public:
+	typedef PopUpTest CLASSNAME;
+	PopUpTest();
+	
+	void DoDrop();
+	void OkCB();
+	void CancelCB();
+	
+	WithPopUpLay<PopUpC> pu;
+};
+
+#endif
+
--- a/bazaar/PopUpTest/PopUpTest.lay
+++ b/bazaar/PopUpTest/PopUpTest.lay
@ -0,0 +1,10 @@
+LAYOUT(PopUpTestLayout, 200, 100)
+	ITEM(Button, drop, SetLabel(t_("Drop")).HSizePosZ(40, 36).BottomPosZ(5, 23))
+END_LAYOUT
+
+LAYOUT(PopUpLay, 400, 200)
+	ITEM(EditInt, ei, HSizePosZ(24, 20).TopPosZ(20, 20))
+	ITEM(Button, ok, SetLabel(t_("OK")).RightPosZ(56, 56).BottomPosZ(0, 20))
+	ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20))
+END_LAYOUT
+
--- a/bazaar/PopUpTest/PopUpTest.upp
+++ b/bazaar/PopUpTest/PopUpTest.upp
@ -0,0 +1,14 @@
+description "PopUpC test package, common base class for PopUps\377";
+
+uses
+	CtrlLib,
+	PopUpC;
+
+file
+	PopUpTest.h,
+	main.cpp,
+	PopUpTest.lay;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/PopUpTest/init
+++ b/bazaar/PopUpTest/init
@ -0,0 +1,5 @@
+#ifndef _PopUpTest_icpp_init_stub
+#define _PopUpTest_icpp_init_stub
+#include "CtrlLib/init"
+#include "PopUpC/init"
+#endif
--- a/bazaar/PopUpTest/main.cpp
+++ b/bazaar/PopUpTest/main.cpp
@ -0,0 +1,38 @@
+#include "PopUpTest.h"
+
+void PopUpTest::OkCB()
+{
+	String a = AsString(pu.ei.GetData());
+	drop.SetLabel(String().Cat() << "dropped OK, " << a);
+}
+
+void PopUpTest::CancelCB()
+{
+	drop.SetLabel("dropped Cancel");
+}
+
+void PopUpTest::DoDrop()
+{
+	drop.SetLabel("dropping");
+	pu.ei.SetData(123);
+	pu.PopUp(this);
+}
+
+PopUpTest::PopUpTest()
+{
+	CtrlLayout(*this, "Window title");
+
+	CtrlLayout(pu);
+	pu.ok <<= callback(&pu, &PopUpC::Acceptor);
+	pu.cancel <<= callback(&pu, &PopUpC::Rejector);
+	pu.WhenSelect = THISBACK(OkCB);
+	pu.WhenCancel = THISBACK(CancelCB);
+
+	drop <<= THISBACK(DoDrop);
+}
+
+GUI_APP_MAIN
+{
+	PopUpTest().Run();
+}
+
--- a/bazaar/RectCtrl/RectCtrl.cpp
+++ b/bazaar/RectCtrl/RectCtrl.cpp
@ -0,0 +1,218 @@
+#include "RectCtrl.h"
+
+#define IMAGECLASS Img
+#define IMAGEFILE <RectCtrl/icons.iml>
+#include <Draw/iml_source.h>
+
+CH_STYLE(RectCtrl, Style, StyleDefault)
+{
+	rectcol = Cyan;
+	handcol = SColorHighlight();
+	handsize = 2;
+	framecol = SColorHighlight();
+	framesize = 1;
+	textcol = SColorPaper();
+}
+
+Rect RectCtrl::HandleAt(const Point& p, int size)
+{
+	Rect q(p,p); q.Inflate(size); return q;
+}
+
+void RectCtrl::Paint(Draw& w)
+{
+	Size sz = GetSize();
+
+	if(r.IsNullInstance()) return;
+	
+	//rect
+	w.DrawRect(r, style->rectcol);
+
+	//handle frame
+	Vector<Point> vp;
+	vp << r.TopLeft() << r.TopRight() << r.BottomRight() << r.BottomLeft() << r.TopLeft();
+	w.DrawPolyline(vp, style->framesize, style->framecol);
+	
+	//handles
+	int size = style->handsize;
+	w.DrawRect(HandleAt(r.CenterPoint(), size), style->handcol);
+
+	w.DrawRect(HandleAt(r.TopLeft(), size), style->handcol);
+	w.DrawRect(HandleAt(r.BottomRight(), size), style->handcol);
+	w.DrawRect(HandleAt(r.TopRight(), size), style->handcol);
+	w.DrawRect(HandleAt(r.BottomLeft(), size), style->handcol);
+
+	w.DrawRect(HandleAt(r.CenterLeft(), size), style->handcol);
+	w.DrawRect(HandleAt(r.CenterRight(), size), style->handcol);
+	w.DrawRect(HandleAt(r.TopCenter(), size), style->handcol);
+	w.DrawRect(HandleAt(r.BottomCenter(), size), style->handcol);
+	
+	//text
+	if(pressed && moving)
+	{
+		String t = AsString(r);
+		Size tsz = GetTextSize(t, StdFont());
+		w.DrawRect(10, 10, tsz.cx, tsz.cy, style->framecol);
+		w.DrawText(10, 10, t, StdFont(), style->textcol);
+	}
+}
+
+int RectCtrl::GetMode(const Point& p, dword keyflags)
+{
+	int size = style->handsize<<1;
+	Rect q = r; q.Inflate(size);
+	if(!q.Contains(p)) return NONE;
+
+	if(HandleAt(r.TopLeft(), size).Contains(p)) return LEFTTOP;
+	if(HandleAt(r.BottomRight(), size).Contains(p)) return RIGHTBOTTOM;
+	if(HandleAt(r.TopRight(), size).Contains(p)) return RIGHTTOP;
+	if(HandleAt(r.BottomLeft(), size).Contains(p)) return LEFTBOTTOM;
+
+	if(HandleAt(r.CenterLeft(), size).Contains(p)) return LEFT;
+	if(HandleAt(r.CenterRight(), size).Contains(p)) return RIGHT;
+	if(HandleAt(r.TopCenter(), size).Contains(p)) return TOP;
+	if(HandleAt(r.BottomCenter(), size).Contains(p)) return BOTTOM;
+
+	if(HandleAt(r.CenterPoint(), size).Contains(p)) return CENTER;
+
+	return MOVE;
+}
+
+void RectCtrl::CalcRect(const Point& dp, dword keyflags)
+{
+	if(mode == NONE) return;
+	r = xr;
+
+	Point p = dp;
+	int m = mode;
+
+	if(!(keyflags & K_ALT)) m |= GRID;
+	if(m & GRIDX) p.x = dp.x/g.x*g.x;
+	if(m & GRIDY) p.y = dp.y/g.y*g.y;
+
+	if(keyflags & K_CTRL)
+	{
+		double dYdX = double(r.Height())/r.Width();
+		switch(m & ALL)
+		{
+			case LEFTTOP: 
+			case RIGHTBOTTOM: p.y = int(p.x*double(r.Height())/r.Width()); break;
+			case RIGHTTOP: 
+			case LEFTBOTTOM: p.y = -int(p.x*double(r.Height())/r.Width()); break;
+			
+			case LEFT: m |= TOP; p.y = int(p.x*double(r.Height())/r.Width()); break;
+			case BOTTOM: m |= RIGHT; p.x = int(p.y*double(r.Width())/r.Height()); break;
+			case RIGHT: m |= BOTTOM; p.y = int(p.x*double(r.Height())/r.Width()); break;
+			case TOP: m |= LEFT; p.x = int(p.y*double(r.Width())/r.Height()); break;
+		}
+	}
+
+	if(keyflags & K_SHIFT)
+	{
+		if(m & LEFT)  m |= _RIGHT;
+		if(m & RIGHT) m |= _LEFT;
+		if(m & TOP)   m |= _BOTTOM;
+		if(m & BOTTOM)m |= _TOP;
+	}
+
+	if(m & LEFT)   r.left += p.x;
+	if(m & RIGHT)  r.right += p.x;
+	if(m & TOP)    r.top += p.y;
+	if(m & BOTTOM) r.bottom += p.y;
+
+	if(m & _LEFT)  r.left -= p.x;
+	if(m & _RIGHT) r.right -= p.x;
+	if(m & _TOP)   r.top -= p.y;
+	if(m & _BOTTOM)r.bottom -= p.y;
+}
+
+void RectCtrl::SetCursor(unsigned m, dword keyflags)
+{
+	switch(m & (ALL | _ALL))
+	{
+		case LEFTTOP: c = OverrideCursor(Img::ltrb()); break;
+		case RIGHTBOTTOM: c = OverrideCursor(Img::ltrb()); break;
+		case RIGHTTOP: c = OverrideCursor(Img::rtlb()); break; 
+		case LEFTBOTTOM: c = OverrideCursor(Img::rtlb()); break;
+		
+		case LEFT: c = OverrideCursor(Img::lr()); break;
+		case BOTTOM: c = OverrideCursor(Img::tb()); break;
+		case RIGHT:  c = OverrideCursor(Img::lr()); break;
+		case TOP: c = OverrideCursor(Img::tb()); break;
+
+		case ALL: c = OverrideCursor(Img::mv()); break;
+		case CENTER: c = OverrideCursor(Img::fr()); break;
+		
+		default: OverrideCursor(c); break;
+	}
+}
+
+void RectCtrl::LeftDown(Point p, dword keyflags)
+{
+	SetCapture();
+	moving = false;
+	pressed = (keyflags & K_MOUSELEFT);
+
+	xr = r;
+	xp = p;
+	mode = GetMode(p, keyflags);
+
+	SetCursor(mode, keyflags);
+	
+	if(mode == NONE) WhenMissed(p, keyflags);
+}
+
+void RectCtrl::MouseMove(Point p, dword keyflags)
+{
+	moving = true;
+	pressed = (keyflags & K_MOUSELEFT);
+
+	//int m = GetMode(p, keyflags);
+	//SetCursor(m, keyflags);
+
+	if(pressed && mode != NONE) 
+	{
+		CalcRect(p-xp, keyflags);	
+		UpdateActionRefresh();
+	}
+	else Refresh();
+}
+
+void RectCtrl::LeftUp(Point p, dword keyflags)
+{
+	ReleaseCapture();
+	pressed = false;
+	moving = false;
+	xr.SetNull();
+	xp.SetNull();
+	mode = NONE;
+	SetCursor(mode, keyflags);
+	Refresh();
+}
+
+void RectCtrl::RightDown(Point p, dword keyflags)
+{
+	//cancel
+	ReleaseCapture();
+	mode = NONE;
+	SetCursor(mode, keyflags);
+	if(xr.IsNullInstance()) return;
+	r = xr;
+	UpdateActionRefresh();
+}
+
+void RectCtrl::Updated()
+{
+	
+}
+
+RectCtrl::RectCtrl()
+	: pressed(false), moving(false)
+{
+	Transparent();
+	style = &StyleDefault();
+	r.SetNull();
+	g = Point(4,4);
+	xr.SetNull();
+	xp.SetNull();
+}
--- a/bazaar/RectCtrl/RectCtrl.h
+++ b/bazaar/RectCtrl/RectCtrl.h
@ -0,0 +1,104 @@
+#ifndef _RectCtrl_RectCtrl_h
+#define _RectCtrl_RectCtrl_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define IMAGECLASS Img
+#define IMAGEFILE <RectCtrl/icons.iml>
+#include <Draw/iml_header.h>
+
+class RectCtrl : public Ctrl
+{
+public:
+	typedef RectCtrl CLASSNAME;
+	RectCtrl();	
+	
+	struct Style : public ChStyle<Style> {
+		Color rectcol;
+		Color handcol;
+		int handsize;
+		Color framecol;
+		int framesize;
+		Color textcol;
+	};
+
+	virtual void Paint(Draw& w);
+	virtual void LeftDown(Point p, dword keyflags);
+	virtual void MouseMove(Point p, dword keyflags);
+	virtual void LeftUp(Point p, dword keyflags);
+	virtual void RightDown(Point p, dword keyflags);
+
+	virtual void Updated();
+
+	virtual void SetData(const Value& v) { r = v; Refresh(); }
+	virtual Value GetData() const { return r; }
+
+	static const Style& StyleDefault();
+	void SetStyle(const Style& s) { style = &s; Refresh(); }
+
+	Callback2<Point, dword> WhenMissed;
+	
+protected:
+	inline static Rect HandleAt(const Point& p, int size);
+	int GetMode(const Point& p, dword keyflags);
+	void CalcRect(const Point& dp, dword keyflags);
+	void SetCursor(unsigned m, dword keyflags);
+
+protected:
+	const Style* style;
+	Rect r;
+	Point g; //grid
+
+	enum 
+	{
+		NONE = 0x0,
+
+		LEFT = 0x1,
+		RIGHT = 0x2,
+		TOP = 0x4,
+		BOTTOM = 0x8,
+
+		_LEFT = 0x10,
+		_RIGHT = 0x20,
+		_TOP = 0x40,
+		_BOTTOM = 0x80,
+
+		LEFTTOP = LEFT | TOP,
+		LEFTBOTTOM = LEFT | BOTTOM,
+		RIGHTTOP = RIGHT | TOP,
+		RIGHTBOTTOM = RIGHT | BOTTOM,
+
+		MOVE = LEFTTOP | RIGHTBOTTOM,
+		ALL = MOVE,
+
+		_LEFTTOP = _LEFT | _TOP,
+		_LEFTBOTTOM = _LEFT | _BOTTOM,
+		_RIGHTTOP = _RIGHT | _TOP,
+		_RIGHTBOTTOM = _RIGHT | _BOTTOM,
+
+		STRETCH = _LEFTTOP | RIGHTBOTTOM,
+		CENTER = STRETCH,
+		_STRETCH = LEFTTOP | _RIGHTBOTTOM,
+		_CENTER = _STRETCH,
+
+		_MOVE = _LEFTTOP | _RIGHTBOTTOM,
+		_ALL = _MOVE,
+
+		GRIDX = 0x100,
+		GRIDY = 0x200,
+		GRID = GRIDX | GRIDY,
+	};
+
+	//cache
+	Point xp;
+	Rect xr;
+	int mode;
+	bool pressed;
+	bool moving;
+	Image c; //cursoroverride
+};
+
+#endif
+
--- a/bazaar/RectCtrl/RectCtrl.upp
+++ b/bazaar/RectCtrl/RectCtrl.upp
@ -0,0 +1,10 @@
+description "Rect editing and placement\377";
+
+uses
+	CtrlLib;
+
+file
+	RectCtrl.h,
+	RectCtrl.cpp,
+	icons.iml;
+
--- a/bazaar/RectCtrl/icons.iml
+++ b/bazaar/RectCtrl/icons.iml
@ -0,0 +1,33 @@
+PREMULTIPLIED
+IMAGE_ID(lt)
+IMAGE_ID(t)
+IMAGE_ID(rt)
+IMAGE_ID(r)
+IMAGE_ID(rb)
+IMAGE_ID(b)
+IMAGE_ID(lb)
+IMAGE_ID(l)
+IMAGE_ID(fr)
+IMAGE_ID(lr)
+IMAGE_ID(tb)
+IMAGE_ID(mv)
+IMAGE_ID(ltrb)
+IMAGE_ID(rtlb)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,153,205,110,195,32,16,132,247,16,169,135,28,154,247,127,217,54,150,47,22,2,118,119,102,128,252,240,85,145)
+IMAGE_DATA(98,194,12,216,44,11,184,246,176,135,253,62,255,54,31,207,95,227,195,234,163,30,104,187,189,246,17,125,233,133,232,25)
+IMAGE_DATA(143,154,39,242,60,90,158,56,71,50,248,177,187,204,175,3,115,211,138,32,80,4,112,214,163,22,128,229,247,40,138,160)
+IMAGE_DATA(121,103,253,102,52,71,50,176,189,51,248,68,70,37,65,182,31,140,22,221,201,152,225,247,95,150,33,90,171,92,123,30)
+IMAGE_DATA(243,57,146,193,237,185,55,216,164,80,173,146,179,60,188,29,142,231,193,234,61,207,153,218,171,126,115,229,220,25,200,25)
+IMAGE_DATA(17,228,204,170,96,149,235,172,199,236,149,173,229,129,182,203,220,191,34,121,109,94,157,243,157,193,109,117,55,54,62,171)
+IMAGE_DATA(207,236,43,244,173,100,172,218,17,101,250,160,60,238,32,140,79,198,231,127,19,150,194,156,165,144,173,50,162,45,245,170)
+IMAGE_DATA(149,54,131,122,135,177,98,82,108,94,153,35,25,220,247,59,131,22,138,76,190,242,60,141,76,96,86,95,122,160,40,61)
+IMAGE_DATA(54,17,206,99,130,52,25,68,130,167,87,39,26,120,179,244,72,255,107,245,188,178,94,63,35,101,30,171,38,86,182,255)
+IMAGE_DATA(236,243,251,246,248,195,25,144,12,62,9,111,48,34,90,111,48,179,90,175,142,183,170,183,62,42,61,219,255,200,239,209)
+IMAGE_DATA(73,192,140,223,247,49,49,25,48,3,192,100,193,72,240,102,181,81,143,107,189,214,247,40,108,0,191,163,158,125,126,236)
+IMAGE_DATA(248,245,60,50,40,86,241,241,9,108,39,131,97,237,71,131,213,107,47,210,167,86,121,109,197,143,214,67,245,108,255,175)
+IMAGE_DATA(191,123,160,19,58,195,78,6,4,236,195,83,103,242,44,170,129,47,189,16,61,227,81,243,100,130,169,55,241,25,15,38)
+IMAGE_DATA(62,16,125,233,161,138,19,180,93,213,252,224,89,240,206,64,57,209,103,15,102,175,31,136,214,12,191,255,178,12,209,90)
+IMAGE_DATA(229,186,86,150,185,79,54,153,169,146,169,106,108,179,168,23,51,221,100,119,248,7,94,65,199,225,0,0,0,0,0,0)
+IMAGE_END_DATA(480, 14)
--- a/bazaar/RectCtrl/init
+++ b/bazaar/RectCtrl/init
@ -0,0 +1,4 @@
+#ifndef _RectCtrl_icpp_init_stub
+#define _RectCtrl_icpp_init_stub
+#include "CtrlLib/init"
+#endif
--- a/bazaar/RectCtrlTest/RectCtrlTest.h
+++ b/bazaar/RectCtrlTest/RectCtrlTest.h
@ -0,0 +1,20 @@
+#ifndef _RectCtrlTest_RectCtrlTest_h
+#define _RectCtrlTest_RectCtrlTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#include <RectCtrl/RectCtrl.h>
+
+#define LAYOUTFILE <RectCtrlTest/RectCtrlTest.lay>
+#include <CtrlCore/lay.h>
+
+class RectCtrlTest : public WithRectCtrlTestLayout<TopWindow> {
+public:
+	typedef RectCtrlTest CLASSNAME;
+	RectCtrlTest();
+};
+
+#endif
+
--- a/bazaar/RectCtrlTest/RectCtrlTest.lay
+++ b/bazaar/RectCtrlTest/RectCtrlTest.lay
@ -0,0 +1,4 @@
+LAYOUT(RectCtrlTestLayout, 640, 480)
+	ITEM(RectCtrl, rc, HSizePosZ(0, 0).VSizePosZ(0, 0))
+END_LAYOUT
+
--- a/bazaar/RectCtrlTest/RectCtrlTest.upp
+++ b/bazaar/RectCtrlTest/RectCtrlTest.upp
@ -0,0 +1,14 @@
+description "RectCtrl Test package, Rect placement and editing\377";
+
+uses
+	CtrlLib,
+	RectCtrl;
+
+file
+	RectCtrlTest.h,
+	main.cpp,
+	RectCtrlTest.lay;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/RectCtrlTest/main.cpp
+++ b/bazaar/RectCtrlTest/main.cpp
@ -0,0 +1,19 @@
+#include "RectCtrlTest.h"
+
+
+
+RectCtrlTest::RectCtrlTest()
+{
+	CtrlLayout(*this, "Window title");
+	Sizeable().Zoomable();
+
+	Rect r = rc.GetRect();
+	r.Deflate(r.Width()/4, r.Height()/4);
+	rc.SetData(r);
+}
+
+GUI_APP_MAIN
+{
+	RectCtrlTest().Run();
+}
+
--- a/bazaar/Styler/Styler.cpp
+++ b/bazaar/Styler/Styler.cpp
@ -0,0 +1,288 @@
+#include "Styler.h"
+
+#define ADDSTYLE 1
+
+#define IMAGECLASS StylerCtrlsImg
+#define IMAGEFILE <Styler/StylerCtrls.iml>
+#include <Draw/iml_source.h>
+
+void ColorizeIml(Iml& target, Iml& source, const Color& c, int alpha)
+{
+	for(int i = 0; i < target.GetCount(); i++) {
+		int q = source.Find(target.GetId(i));
+		if(q >= 0) {
+			Image m = Colorize(source.Get(q), c, alpha);
+			target.Set(i, m);
+		}
+	}
+}
+
+void RefreshGlobalStyles()
+{
+	{
+		MenuBar::Style& st = MenuBar::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		ToolBar::Style& st = ToolBar::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		StatusBar::Style& st = StatusBar::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		ScrollBar::Style& st = ScrollBar::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		Splitter::Style& st = Splitter::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		Button::Style& st = Button::StyleNormal().Write();
+		st = st.Standard();
+	}
+	{
+		ButtonOption::Style& st = ButtonOption::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		SpinButtons::Style& st = SpinButtons::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		EditField::Style& st = EditField::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		HeaderCtrl::Style& st = HeaderCtrl::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		TabCtrl::Style& st = TabCtrl::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		DropList::Style& st = DropList::StyleDefault().Write();
+		st = st.Standard();
+	}
+#ifdef ADDSTYLE
+	{
+		ArrayCtrl::Style& st = ArrayCtrl::StyleDefault().Write();
+		st = st.Standard();
+	}
+	{
+		TextCtrl::Style& st = TextCtrl::StyleDefault().Write();
+		st = st.Standard();
+	}
+#endif
+}
+
+void RefreshLayoutDeepAll()
+{
+	Vector<Ctrl*> vc = Ctrl::GetTopWindows();
+	for(int i = 0; i < vc.GetCount(); i++)
+		vc[i]->RefreshLayoutDeep();
+}
+
+void StylerCtrl::ColorizedSkin()
+{
+	Color c  = ~mcl;
+	int blnd = ~bl;
+	Color fg = ~fgcl;
+	Color bg = ~bgcl;
+	
+	ChStdSkin();
+	ColorizeIml(CtrlsImg::Iml(), StylerCtrlsImg::Iml(), c, 255);
+
+	if(Grayscale(fg)<Grayscale(bg))
+	{
+		dk <<= true;
+	}
+	else
+	{
+		dk <<= false;
+	}
+
+		SColorFace_Write(Blend(c, fg, blnd)); //controls face color
+		SColorShadow_Write(Blend(c, bg, blnd));
+		SColorLtFace_Write(Blend(c, fg, blnd+20));
+		SColorDkShadow_Write(Blend(c, bg, blnd+20));
+
+		SColorHighlight_Write(Blend(fg, c, blnd+20));
+		SColorDisabled_Write(Blend(bg, c, blnd+20));
+
+		SColorPaper_Write(Blend(c, fg, blnd+40)); //for lists, edits etc..
+		SColorText_Write(Blend(c, bg, blnd+40));
+
+		SColorHighlightText_Write(Blend(c, fg, blnd+60));
+
+
+	SColorLight_Write(SColorHighlight());
+
+	SColorMenu_Write(SColorPaper());
+	SColorMenuText_Write(SColorText());
+	SColorInfo_Write(SColorPaper());
+	SColorInfoText_Write(SColorText());
+	SColorMark_Write(SColorText());
+	
+	SColorLabel_Write(SColorText());
+	LabelBoxTextColor_Write(SColorText());
+	LabelBoxColor_Write(SColorHighlight());
+}
+
+void StylerCtrl::Updated()
+{
+	if((int)stsw.GetData() != 2)
+	{
+		mcl.Disable();
+		fgcl.Disable();
+		bgcl.Disable();
+		bl.Disable();
+		inv.Disable();
+	}
+	else
+	{
+		mcl.Enable();
+		fgcl.Enable();
+		bgcl.Enable();
+		bl.Enable();
+		inv.Enable();
+	}
+
+	//reset
+	switch((int)stsw.GetData())
+	{
+		case 1: ChStdSkin(); break;
+		case 2: ColorizedSkin(); break;
+		default:
+		case 0: ChClassicSkin(); break;
+	}
+
+	RefreshGlobalStyles();
+	RefreshLayoutDeepAll();
+}
+
+void StylerCtrl::InvertColors()
+{
+	Color c  = ~mcl;
+	Color fg = ~fgcl;
+	Color bg = ~bgcl;
+
+	fg = Color(255-fg.GetR(), 255-fg.GetG(),255-fg.GetB());
+	bg = Color(255-bg.GetR(), 255-bg.GetG(),255-bg.GetB());
+	c =  Color(255- c.GetR(), 255- c.GetG(),255- c.GetB());
+	
+	fgcl <<= fg;
+	bgcl <<= bg;
+	mcl  <<= c;
+
+	UpdateAction();
+}
+
+StylerCtrl::StylerCtrl()
+{
+	CtrlLayout(*this);
+
+	dk.SetReadOnly();
+
+	stsw <<= 2;
+	stsw <<= THISBACK(UpdateAction);
+
+	mcl <<= Gray();
+	mcl <<= THISBACK(UpdateAction);
+
+	fgcl <<= White();
+	mcl <<= THISBACK(UpdateAction);
+
+	bgcl <<= Black();
+	bgcl <<= THISBACK(UpdateAction);
+	
+
+	bl.MinMax(0,255);
+	bl <<= 192;
+	bl <<= THISBACK(UpdateAction);
+
+	inv <<= THISBACK(InvertColors);
+
+	UpdateAction();
+}
+
+//
+
+void ChamStyleCtrl::Reload()
+{
+	clface <<= SColorFace();
+	clshadow <<= SColorShadow();
+	clltface <<= SColorLtFace();
+	cldkshadow <<= SColorDkShadow();
+	clhighlight <<= SColorHighlight();
+	cldisabled <<= SColorDisabled();
+	clpaper <<= SColorPaper();
+	cltext <<= SColorText();
+	clhighlighttext <<= SColorHighlightText();
+	cllight <<= SColorLight();
+
+	clmenu <<= SColorMenu();
+	clmenutext <<= SColorMenuText();
+	clinfo <<= SColorInfo();
+	clinfotext <<= SColorInfoText();
+	clmark <<= SColorMark();
+	cllabel <<= SColorLabel();
+	cllbtext <<= LabelBoxTextColor();
+	cllb <<= LabelBoxColor();
+}
+
+void ChamStyleCtrl::Updated()
+{
+	SColorFace_Write(~clface);
+	SColorShadow_Write(~clshadow);
+	SColorLtFace_Write(~clltface);
+	SColorDkShadow_Write(~cldkshadow);
+	SColorHighlight_Write(~clhighlight);
+	SColorDisabled_Write(~cldisabled);
+	SColorPaper_Write(~clpaper);
+	SColorText_Write(~cltext);
+	SColorHighlightText_Write(~clhighlighttext);
+	SColorLight_Write(~cllight);
+
+	SColorMenu_Write(~clmenu);
+	SColorMenuText_Write(~clmenutext);
+	SColorInfo_Write(~clinfo);
+	SColorInfoText_Write(~clinfotext);
+	SColorMark_Write(~clmark);
+	SColorLabel_Write(~cllabel);
+	LabelBoxTextColor_Write(~cllbtext);
+	LabelBoxColor_Write(~cllb);
+
+	RefreshGlobalStyles();
+	RefreshLayoutDeepAll();
+}
+
+ChamStyleCtrl::ChamStyleCtrl()
+{
+	CtrlLayout(*this);
+	
+	clface <<= THISBACK(UpdateAction);
+	clshadow <<= THISBACK(UpdateAction);
+	clltface <<= THISBACK(UpdateAction);
+	cldkshadow <<= THISBACK(UpdateAction);
+	clhighlight <<= THISBACK(UpdateAction);
+	cldisabled <<= THISBACK(UpdateAction);
+	clpaper <<= THISBACK(UpdateAction);
+	cltext <<= THISBACK(UpdateAction);
+	clhighlighttext <<= THISBACK(UpdateAction);
+	cllight <<= THISBACK(UpdateAction);
+
+	clmenu <<= THISBACK(UpdateAction);
+	clmenutext <<= THISBACK(UpdateAction);
+	clinfo <<= THISBACK(UpdateAction);
+	clinfotext <<= THISBACK(UpdateAction);
+	clmark <<= THISBACK(UpdateAction);
+	cllabel <<= THISBACK(UpdateAction);
+	cllbtext <<= THISBACK(UpdateAction);
+	cllb <<= THISBACK(UpdateAction);
+	 
+	Reload();	
+}
--- a/bazaar/Styler/Styler.h
+++ b/bazaar/Styler/Styler.h
@ -0,0 +1,44 @@
+#ifndef _Styler_Styler_h
+#define _Styler_Styler_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define IMAGECLASS StylerCtrlsImg
+#define IMAGEFILE <Styler/StylerCtrls.iml>
+#include <Draw/iml_header.h>
+
+void ColorizeIml(Iml& target, Iml& source, const Color& c, int alpha = 100);
+void RefreshGlobalStyles();
+void RefreshLayoutDeepAll();
+
+#define LAYOUTFILE <Styler/Styler.lay>
+#include <CtrlCore/lay.h>
+
+class StylerCtrl : public WithStylerLay<ParentCtrl> {
+public:
+	typedef StylerCtrl CLASSNAME;
+	StylerCtrl();
+
+	virtual void Updated();
+	void InvertColors();
+
+protected:
+	void ColorizedSkin();
+	void ColorAction();
+};
+
+class ChamStyleCtrl : public WithChamStyleLay<ParentCtrl> {
+public:
+	typedef ChamStyleCtrl CLASSNAME;
+	ChamStyleCtrl();
+
+	void Reload();
+	virtual void Updated();
+protected:
+	void ColorAction();
+};
+
+#endif
+
--- a/bazaar/Styler/Styler.lay
+++ b/bazaar/Styler/Styler.lay
@ -0,0 +1,52 @@
+LAYOUT(StylerLay, 160, 116)
+	ITEM(ColorPusher, mcl, LeftPosZ(48, 28).TopPosZ(4, 20))
+	ITEM(ColorPusher, fgcl, LeftPosZ(48, 28).TopPosZ(24, 20))
+	ITEM(ColorPusher, bgcl, LeftPosZ(48, 28).TopPosZ(44, 20))
+	ITEM(Switch, stsw, SetLabel(t_("ClassicSkin\nStdSkin\nStylerSkin")).RightPosZ(4, 76).TopPosZ(4, 60))
+	ITEM(Option, inv, SetLabel(t_("inverted")).RightPosZ(4, 76).VSizePosZ(68, 32))
+	ITEM(SliderCtrl, bl, HSizePosZ(4, 4).BottomPosZ(4, 24))
+	ITEM(StaticText, dv___6, SetText(t_("main:")).LeftPosZ(4, 40).TopPosZ(4, 19))
+	ITEM(StaticText, dv___7, SetText(t_("fg:")).LeftPosZ(4, 40).TopPosZ(24, 19))
+	ITEM(StaticText, dv___8, SetText(t_("bg:")).LeftPosZ(4, 40).TopPosZ(44, 19))
+	ITEM(Option, dk, SetLabel(t_("dark")).LeftPosZ(4, 72).VSizePosZ(68, 32))
+END_LAYOUT
+
+LAYOUT(ChamStyleLay, 400, 208)
+	ITEM(ColorPusher, clface, LeftPosZ(124, 20).TopPosZ(4, 20))
+	ITEM(StaticText, dv___1, SetText(t_("SColorFace")).LeftPosZ(4, 116).TopPosZ(4, 19))
+	ITEM(ColorPusher, clshadow, LeftPosZ(124, 20).TopPosZ(24, 20))
+	ITEM(StaticText, dv___3, SetText(t_("SColorShadow")).LeftPosZ(4, 116).TopPosZ(24, 19))
+	ITEM(ColorPusher, clltface, LeftPosZ(124, 20).TopPosZ(44, 20))
+	ITEM(StaticText, dv___5, SetText(t_("SColorLtFace")).LeftPosZ(4, 116).TopPosZ(44, 19))
+	ITEM(ColorPusher, cldkshadow, LeftPosZ(124, 20).TopPosZ(64, 20))
+	ITEM(StaticText, dv___7, SetText(t_("SColorDkShadow")).LeftPosZ(4, 116).TopPosZ(64, 19))
+	ITEM(ColorPusher, clhighlight, LeftPosZ(124, 20).TopPosZ(84, 20))
+	ITEM(StaticText, dv___9, SetText(t_("SColorHighlight")).LeftPosZ(4, 116).TopPosZ(84, 19))
+	ITEM(ColorPusher, cldisabled, LeftPosZ(124, 20).TopPosZ(104, 20))
+	ITEM(StaticText, dv___11, SetText(t_("SColorDisabled")).LeftPosZ(4, 116).TopPosZ(104, 19))
+	ITEM(ColorPusher, clpaper, LeftPosZ(124, 20).TopPosZ(124, 20))
+	ITEM(StaticText, dv___13, SetText(t_("SColorPaper")).LeftPosZ(4, 116).TopPosZ(124, 19))
+	ITEM(ColorPusher, cltext, LeftPosZ(124, 20).TopPosZ(144, 20))
+	ITEM(StaticText, dv___15, SetText(t_("SColorText")).LeftPosZ(4, 116).TopPosZ(144, 19))
+	ITEM(ColorPusher, clhighlighttext, LeftPosZ(124, 20).TopPosZ(164, 20))
+	ITEM(StaticText, dv___17, SetText(t_("SColorHighlightText")).LeftPosZ(4, 116).TopPosZ(164, 19))
+	ITEM(ColorPusher, cllight, LeftPosZ(124, 20).TopPosZ(184, 20))
+	ITEM(StaticText, dv___19, SetText(t_("SColorLight")).LeftPosZ(4, 116).TopPosZ(184, 19))
+	ITEM(ColorPusher, clmenu, LeftPosZ(288, 20).TopPosZ(4, 20))
+	ITEM(StaticText, dv___21, SetText(t_("SColorMenu")).LeftPosZ(168, 116).TopPosZ(4, 19))
+	ITEM(ColorPusher, clmenutext, LeftPosZ(288, 20).TopPosZ(24, 20))
+	ITEM(StaticText, dv___23, SetText(t_("SColorMenuText")).LeftPosZ(168, 116).TopPosZ(24, 19))
+	ITEM(ColorPusher, clinfo, LeftPosZ(288, 20).TopPosZ(44, 20))
+	ITEM(StaticText, dv___25, SetText(t_("SColorInfo")).LeftPosZ(168, 116).TopPosZ(44, 19))
+	ITEM(ColorPusher, clinfotext, LeftPosZ(288, 20).TopPosZ(64, 20))
+	ITEM(StaticText, dv___27, SetText(t_("SColorInfoText")).LeftPosZ(168, 116).TopPosZ(64, 19))
+	ITEM(ColorPusher, clmark, LeftPosZ(288, 20).TopPosZ(84, 20))
+	ITEM(StaticText, dv___29, SetText(t_("SColorMark")).LeftPosZ(168, 116).TopPosZ(84, 19))
+	ITEM(ColorPusher, cllabel, LeftPosZ(288, 20).TopPosZ(104, 20))
+	ITEM(StaticText, dv___31, SetText(t_("SColorLabel")).LeftPosZ(168, 116).TopPosZ(104, 19))
+	ITEM(ColorPusher, cllbtext, LeftPosZ(288, 20).TopPosZ(124, 20))
+	ITEM(StaticText, dv___33, SetText(t_("LabelBoxTextColor")).LeftPosZ(168, 116).TopPosZ(124, 19))
+	ITEM(ColorPusher, cllb, LeftPosZ(288, 20).TopPosZ(144, 20))
+	ITEM(StaticText, dv___35, SetText(t_("LabelBoxColor")).LeftPosZ(168, 116).TopPosZ(144, 19))
+END_LAYOUT
+
--- a/bazaar/Styler/Styler.upp
+++ b/bazaar/Styler/Styler.upp
@ -0,0 +1,12 @@
+description "Style playground, template for editing own style\377";
+
+uses
+	CtrlLib;
+
+file
+	Styler.h,
+	Styler.cpp,
+	unused.cpp,
+	Styler.lay,
+	StylerCtrls.iml;
+
--- a/bazaar/Styler/StylerCtrls.iml
+++ b/bazaar/Styler/StylerCtrls.iml
@ -0,0 +1,187 @@
+PREMULTIPLIED
+IMAGE_ID(S0)
+IMAGE_ID(S0h)
+IMAGE_ID(S0p)
+IMAGE_ID(S0d)
+IMAGE_ID(S1)
+IMAGE_ID(S1h)
+IMAGE_ID(S1p)
+IMAGE_ID(S1d)
+IMAGE_ID(O0)
+IMAGE_ID(O0h)
+IMAGE_ID(O0p)
+IMAGE_ID(O0d)
+IMAGE_ID(O1)
+IMAGE_ID(O1h)
+IMAGE_ID(O1p)
+IMAGE_ID(O1d)
+IMAGE_ID(O2)
+IMAGE_ID(O2h)
+IMAGE_ID(O2p)
+IMAGE_ID(O2d)
+IMAGE_ID(B)
+IMAGE_ID(Bh)
+IMAGE_ID(Bp)
+IMAGE_ID(Bd)
+IMAGE_ID(EB)
+IMAGE_ID(EBh)
+IMAGE_ID(EBp)
+IMAGE_ID(EBd)
+IMAGE_ID(SB)
+IMAGE_ID(SBh)
+IMAGE_ID(SBp)
+IMAGE_ID(SBd)
+IMAGE_ID(SBHT)
+IMAGE_ID(SBHTh)
+IMAGE_ID(SBHTp)
+IMAGE_ID(SBHTd)
+IMAGE_ID(SBVT)
+IMAGE_ID(SBVTh)
+IMAGE_ID(SBVTp)
+IMAGE_ID(SBVTd)
+IMAGE_ID(OkB)
+IMAGE_ID(OkBh)
+IMAGE_ID(OkBp)
+IMAGE_ID(OkBd)
+IMAGE_ID(OBlack)
+IMAGE_ID(SBlack)
+IMAGE_ID(SizeGrip)
+IMAGE_ID(kDA)
+IMAGE_ID(kUA)
+IMAGE_ID(kLA)
+IMAGE_ID(kRA)
+IMAGE_ID(kSpU)
+IMAGE_ID(kSpD)
+IMAGE_ID(DA)
+IMAGE_ID(UA)
+IMAGE_ID(LA)
+IMAGE_ID(RA)
+IMAGE_ID(SpU)
+IMAGE_ID(SpD)
+IMAGE_ID(SBVU)
+IMAGE_ID(SBVUh)
+IMAGE_ID(SBVUp)
+IMAGE_ID(SBVUd)
+IMAGE_ID(SBVL)
+IMAGE_ID(SBVLh)
+IMAGE_ID(SBVLp)
+IMAGE_ID(SBVLd)
+IMAGE_ID(SBHU)
+IMAGE_ID(SBHUh)
+IMAGE_ID(SBHUp)
+IMAGE_ID(SBHUd)
+IMAGE_ID(SBHL)
+IMAGE_ID(SBHLh)
+IMAGE_ID(SBHLp)
+IMAGE_ID(SBHLd)
+IMAGE_ID(SBVI)
+IMAGE_ID(SBHI)
+IMAGE_ID(EFE)
+IMAGE_ID(VE)
+IMAGE_ID(HorzPos)
+IMAGE_ID(HorzSplit)
+IMAGE_ID(HTB)
+IMAGE_ID(HTBh)
+IMAGE_ID(HTBp)
+IMAGE_ID(HTBd)
+IMAGE_ID(PI)
+IMAGE_ID(VPI)
+IMAGE_ID(PIC)
+IMAGE_ID(VPIC)
+IMAGE_ID(TAB)
+IMAGE_ID(TABh)
+IMAGE_ID(TABs)
+IMAGE_ID(TABd)
+IMAGE_ID(FTAB)
+IMAGE_ID(FTABh)
+IMAGE_ID(FTABs)
+IMAGE_ID(FTABd)
+IMAGE_ID(LTAB)
+IMAGE_ID(LTABh)
+IMAGE_ID(LTABs)
+IMAGE_ID(LTABd)
+IMAGE_ID(BTAB)
+IMAGE_ID(BTABh)
+IMAGE_ID(BTABs)
+IMAGE_ID(BTABd)
+IMAGE_ID(TABB)
+IMAGE_ID(SLA)
+IMAGE_ID(SRA)
+IMAGE_ID(TB)
+IMAGE_ID(TBh)
+IMAGE_ID(TBp)
+IMAGE_ID(TBd)
+IMAGE_ID(TB1)
+IMAGE_ID(TB1h)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,152,75,110,195,48,12,68,5,20,69,27,160,222,116,145,243,230,104,61,74,143,18,39,128,1,47,200,225,7)
+IMAGE_DATA(132,101,201,243,180,147,57,148,68,81,12,145,182,180,165,125,172,227,182,142,23,143,0,81,123,66,246,100,242,173,245,78)
+IMAGE_DATA(216,127,128,102,111,249,163,166,70,179,205,71,238,39,194,101,18,214,130,154,26,77,230,126,34,12,153,176,127,0,205,222)
+IMAGE_DATA(242,71,77,141,102,155,143,220,79,132,33,19,182,242,197,87,86,23,106,114,247,19,33,157,176,159,235,248,90,199,40,9)
+IMAGE_DATA(107,249,67,115,146,127,164,209,246,117,6,77,230,60,26,40,222,26,200,159,7,86,88,69,71,13,43,108,106,65,137,163)
+IMAGE_DATA(123,88,201,63,210,104,251,58,131,38,115,30,13,20,111,13,228,207,195,144,21,150,92,151,33,19,54,243,19,101,249,163)
+IMAGE_DATA(134,61,108,201,130,18,153,132,181,160,102,242,30,150,255,195,82,195,30,214,73,229,139,175,172,46,212,228,238,39,194,144)
+IMAGE_DATA(255,18,100,2,104,249,67,115,146,127,164,209,246,117,6,77,230,60,26,40,222,26,200,159,7,86,88,69,71,13,43,108)
+IMAGE_DATA(106,65,137,163,123,88,201,63,210,104,251,58,131,38,115,30,13,20,111,13,228,207,195,144,9,91,249,226,61,213,197,51)
+IMAGE_DATA(191,255,134,246,208,91,147,57,79,36,110,150,78,178,143,112,153,150,192,242,71,13,123,216,146,5,37,50,9,107,65,205)
+IMAGE_DATA(228,21,118,180,30,214,2,105,60,243,251,111,104,15,189,53,153,243,68,226,102,233,36,251,8,169,132,253,105,247,119,133)
+IMAGE_DATA(253,110,191,161,132,173,72,86,66,72,63,162,239,189,91,177,136,182,4,200,15,237,105,63,179,253,54,239,125,47,94,166)
+IMAGE_DATA(45,22,8,218,211,126,102,123,164,145,108,189,68,223,251,19,159,211,90,105,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(416, 23)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,153,93,106,66,65,12,70,3,133,82,68,138,136,148,46,183,75,115,41,93,74,171,56,111,185,153,47,83,188)
+IMAGE_DATA(243,211,115,124,11,231,139,40,38,14,115,237,104,31,246,242,251,122,179,179,221,248,18,201,184,30,215,13,182,220,168,15)
+IMAGE_DATA(62,254,202,126,169,171,243,162,146,157,119,123,183,207,251,178,56,216,37,181,44,90,222,16,0,96,116,90,247,224,48,203)
+IMAGE_DATA(244,187,194,86,70,233,75,142,28,185,249,115,165,30,81,235,171,240,111,151,169,2,57,114,228,230,207,41,89,47,147,101)
+IMAGE_DATA(250,101,186,117,231,17,221,125,40,119,34,217,59,25,114,228,200,141,153,43,245,136,90,95,133,230,101,58,203,3,150,204)
+IMAGE_DATA(23,136,143,191,146,31,101,60,87,37,253,128,165,215,178,200,30,93,163,62,248,248,43,251,165,174,206,139,202,178,203,34)
+IMAGE_DATA(2,31,127,101,63,202,120,174,202,52,203,34,123,4,139,250,224,227,175,236,151,186,58,47,42,233,101,113,120,44,139,87)
+IMAGE_DATA(113,89,180,46,9,229,67,170,95,8,30,222,51,60,207,245,156,26,234,28,237,54,124,234,209,133,26,181,94,181,82,255)
+IMAGE_DATA(235,177,121,218,225,243,192,195,219,195,243,92,207,169,49,220,240,169,127,249,212,168,245,170,149,250,110,199,206,163,93,30)
+IMAGE_DATA(23,68,167,161,47,136,34,240,241,123,250,81,198,115,85,26,110,123,251,12,115,246,104,17,245,193,199,239,233,151,186,250)
+IMAGE_DATA(123,86,89,118,152,35,240,241,123,250,81,198,115,85,178,243,248,3,17,30,80,110,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(352, 16)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,91,75,110,219,48,16,165,107,27,182,19,23,104,131,52,119,232,125,122,158,32,87,41,186,235,58,5,178,236)
+IMAGE_DATA(33,186,204,34,237,69,212,153,64,20,40,122,126,164,44,203,18,230,17,134,45,242,241,205,227,152,36,68,43,9,199,112)
+IMAGE_DATA(31,214,80,246,225,83,64,60,25,81,194,165,240,155,1,199,149,116,156,239,252,41,249,177,222,58,159,173,40,93,143,225)
+IMAGE_DATA(24,30,218,197,124,119,209,197,236,112,56,166,197,108,54,139,55,6,28,87,210,113,190,243,151,204,143,245,214,245,98,197)
+IMAGE_DATA(98,55,11,9,206,119,254,146,249,82,31,138,107,197,108,54,139,146,51,216,181,157,33,157,239,252,75,242,99,189,117,189)
+IMAGE_DATA(88,81,188,89,124,132,178,130,114,11,197,225,184,122,248,132,117,204,10,71,40,99,226,229,249,71,243,242,252,189,41,226)
+IMAGE_DATA(255,178,243,17,13,160,220,153,16,63,241,171,249,143,126,163,7,139,255,220,239,16,255,154,95,242,154,240,91,226,159,194)
+IMAGE_DATA(191,191,175,77,216,133,77,87,193,221,63,32,184,246,84,144,171,79,219,123,21,105,112,145,168,4,40,49,220,181,111,32)
+IMAGE_DATA(188,22,220,44,198,152,227,204,246,130,115,163,225,70,109,53,194,102,115,11,103,57,105,212,214,160,61,33,205,13,153,134)
+IMAGE_DATA(136,3,243,93,72,56,25,86,86,47,5,150,12,90,250,81,237,156,126,145,127,41,17,22,65,171,177,177,18,35,249,212)
+IMAGE_DATA(252,247,176,131,84,112,40,205,252,185,234,47,217,222,93,80,137,152,210,216,165,18,124,82,57,100,215,234,125,166,118,45)
+IMAGE_DATA(238,51,21,160,187,248,12,167,134,136,33,103,236,238,252,236,130,46,88,33,184,2,73,23,116,193,169,5,247,80,240,57)
+IMAGE_DATA(193,166,189,173,103,137,133,1,227,70,44,181,113,28,173,93,211,231,160,141,15,82,113,104,147,177,157,77,50,38,75,22)
+IMAGE_DATA(38,106,213,22,202,68,94,7,57,221,134,15,109,225,148,169,145,164,130,18,239,196,229,61,44,150,3,124,169,55,194,125)
+IMAGE_DATA(105,68,147,65,237,96,208,195,183,40,189,52,61,230,199,21,82,79,211,167,114,174,233,113,154,177,95,133,63,181,15,49)
+IMAGE_DATA(71,76,109,185,214,208,23,165,57,212,223,24,249,75,219,75,245,56,173,172,127,137,191,34,72,122,53,152,131,94,54,63)
+IMAGE_DATA(100,60,192,230,122,3,155,235,109,197,230,106,14,98,208,77,229,195,153,147,123,173,186,210,2,228,116,45,11,170,86,151)
+IMAGE_DATA(211,86,188,88,252,178,245,129,153,86,148,46,197,73,181,211,58,233,149,247,215,184,99,249,29,51,191,105,123,173,46,167)
+IMAGE_DATA(153,233,212,248,45,130,69,183,6,115,212,101,230,149,140,53,220,178,175,224,118,29,95,8,237,96,64,29,32,138,132,168)
+IMAGE_DATA(251,249,105,133,212,161,237,160,172,219,130,200,207,61,239,103,159,164,62,119,89,123,112,179,180,113,241,36,159,203,27,16)
+IMAGE_DATA(222,164,196,71,52,56,237,255,48,37,226,39,83,34,30,153,18,241,141,41,17,95,153,210,45,75,166,88,251,107,241,53)
+IMAGE_DATA(255,218,248,165,252,65,170,247,239,115,72,218,119,40,160,0,6,65,35,104,22,7,132,131,198,119,188,198,122,108,143,193)
+IMAGE_DATA(150,202,45,1,220,122,127,105,127,176,226,127,22,204,247,116,106,121,165,60,174,61,229,57,199,57,215,192,25,125,1,80)
+IMAGE_DATA(127,187,159,114,210,182,244,179,115,156,195,225,172,11,96,215,62,178,88,183,143,44,242,142,218,196,183,4,138,144,254,137)
+IMAGE_DATA(165,182,237,92,248,15,117,238,151,244,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(800, 53)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,150,91,18,130,48,12,69,35,136,232,167,47,214,171,59,99,41,46,197,240,114,74,73,74,71,195,80,135,123)
+IMAGE_DATA(250,3,201,133,22,154,164,161,19,221,41,231,177,167,51,13,60,60,200,195,247,251,58,215,86,247,248,58,215,47,93,67)
+IMAGE_DATA(3,141,134,165,134,150,78,128,95,22,7,13,52,75,107,22,79,128,87,143,182,56,215,231,94,67,3,141,134,105,2,148)
+IMAGE_DATA(156,2,121,59,10,49,192,231,2,63,102,162,1,63,17,44,124,86,44,94,9,208,11,66,243,173,70,195,180,18,160,23)
+IMAGE_DATA(132,102,203,26,244,130,208,36,171,209,48,77,0,244,130,29,232,5,161,73,86,163,97,90,9,208,11,66,179,101,13,122)
+IMAGE_DATA(65,104,146,213,104,152,38,0,122,193,14,244,130,208,36,171,209,48,174,4,37,237,120,20,60,230,30,248,7,232,192,31)
+IMAGE_DATA(164,209,252,105,201,230,219,107,7,201,22,163,15,189,127,178,30,127,209,161,7,66,147,132,22,166,125,76,236,251,39,139)
+IMAGE_DATA(105,194,102,160,253,245,71,170,40,227,81,208,245,99,20,247,136,198,71,162,139,171,147,78,0,237,8,133,31,126,201,166)
+IMAGE_DATA(197,215,92,124,114,74,118,193,156,43,193,44,5,113,204,196,176,167,105,119,125,195,189,182,239,163,210,247,100,184,228,85)
+IMAGE_DATA(109,172,100,116,153,68,75,40,212,192,58,72,123,212,158,95,205,206,30,232,22,125,126,1,176,6,115,241,249,6,18,230)
+IMAGE_DATA(30,106,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(352, 22)
--- a/bazaar/Styler/init
+++ b/bazaar/Styler/init
@ -0,0 +1,4 @@
+#ifndef _Styler_icpp_init_stub
+#define _Styler_icpp_init_stub
+#include "CtrlLib/init"
+#endif
--- a/bazaar/Styler/unused.cpp
+++ b/bazaar/Styler/unused.cpp
@ -0,0 +1,371 @@
+#include "Styler.h"
+
+#define BLENDIT 192
+
+void ChMySkin()
+{
+	ChStdSkin();
+	//Override()	
+}
+
+void SetStyle(int a, bool full)
+{
+	switch(a)
+	{
+		case 1:
+		{
+			ChMySkin();
+			//ChStdSkin();
+			//ChClassicSkin();
+			SColorPaper_Write(Blend(White(), Black(), BLENDIT-20)); //for lists, edits etc..
+			SColorText_Write(LtGray());
+			SColorHighlight_Write(Gray());
+			SColorHighlightText_Write(White());
+			SColorMenu_Write(SColorPaper());
+			SColorMenuText_Write(SColorText());
+			SColorInfo_Write(SColorPaper());
+			SColorInfoText_Write(SColorText());
+			SColorMark_Write(SColorText());
+			SColorDisabled_Write(Blend(White(), Black(), BLENDIT/2));
+			SColorLight_Write(SColorText());
+			SColorFace_Write(Blend(White(), Black(), BLENDIT)); //controls face color
+			SColorLabel_Write(SColorText());
+			SColorShadow_Write(Black());
+	
+			SColorLtFace_Write(LtGray());
+			SColorDkShadow_Write(Gray());
+			
+			LabelBoxTextColor_Write(SColorText());
+			LabelBoxColor_Write(SColorHighlight());
+		}
+			break;
+		default:
+		{
+			ChStdSkin();
+			//ChClassicSkin();
+			//ChHostSkin();
+		}
+			break;
+	}
+	
+	if(!full) return;
+
+	if(1)
+	{
+		MenuBar::Style& st = MenuBar::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+				
+				//area background, seem to be same
+				//st.arealook = SColorFace();
+				//st.look = SColorFace();
+				
+				//st.item = SColorPaper();
+				//st.look = White();
+		
+				//popop menu body color
+				//st.popupbody = SColorPaper();
+				//surrounding menu frame color
+				//st.popupframe = Black();
+				//popup iconbar back color
+				//st.popupiconbar = SColorFace();
+				//??
+				//ms.topbar = SColorPaper();
+				
+				//topitem background color
+				//st.topitem[0] = Red(); //unseleced
+				//st.topitem[1] = Green(); //mouseover
+				//st.topitem[2] = Blue(); //selected
+				//topitem text color
+				//st.topitemtext[0] = Black(); //unselected
+				//st.topitemtext[1] = Black(); //mouseover
+				//st.topitemtext[2] = Black(); //selected
+				//selected item text color
+				//st.itemtext = White();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		ToolBar::Style& st = ToolBar::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+				//st.arealook = SColorFace();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		StatusBar::Style& st = StatusBar::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+				//st.look = SColorFace();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		ScrollBar::Style& st = ScrollBar::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+/*
+				DfmCtrlsImageLook(st.vupper, DfmCtrlsImg::I_SBVU);
+				DfmCtrlsImageLook(st.vthumb, DfmCtrlsImg::I_SBVT, DfmCtrlsImg::SBVI());
+				DfmCtrlsImageLook(st.vlower, DfmCtrlsImg::I_SBVL);
+				DfmCtrlsImageLook(st.hupper, DfmCtrlsImg::I_SBHU);
+				DfmCtrlsImageLook(st.hthumb, DfmCtrlsImg::I_SBHT, DfmCtrlsImg::SBHI());
+				DfmCtrlsImageLook(st.hlower, DfmCtrlsImg::I_SBHL);
+		
+				Sb_night(st.up, CtrlsImg::UA());
+				Sb_night(st.up2, CtrlsImg::UA());
+				Sb_night(st.down, CtrlsImg::DA());
+				Sb_night(st.down2, CtrlsImg::DA());
+				Sb_night(st.left, CtrlsImg::LA());
+				Sb_night(st.left2, CtrlsImg::LA());
+				Sb_night(st.right, CtrlsImg::RA());
+				Sb_night(st.right2, CtrlsImg::RA());
+*/
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		Splitter::Style& st = Splitter::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+				//st.look = SColorFace();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		//BUTTONS
+/*
+		Button::Style& bsNormal = Button::StyleNormal().Write();
+		Button::Style& bsOk = Button::StyleOk().Write();
+		Button::Style& bsScroll = Button::StyleScroll().Write();
+		Button::Style& bsEdge = Button::StyleEdge().Write();
+*/
+		Button::Style& st = Button::StyleNormal().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+/*
+				bsNormal = bsNormal.Standard();
+				bsOk = bsOk.Standard();
+				bsScroll = bsScroll.Standard();
+				bsEdge = bsEdge.Standard();
+		
+				DfmCtrls2ImageLook(bsNormal.look, DfmCtrlsImg2::I_B);
+				DfmCtrls2ImageLook(bsOk.look, DfmCtrlsImg2::I_B);
+				DfmCtrlsImageLook(bsScroll.look, DfmCtrlsImg::I_SB);
+				DfmCtrls3ImageLook(bsEdge.look, DfmCtrlsImg3::I_EB);
+			
+				for(int i = 0; i < 3; i++)
+				{
+					bsNormal.textcolor[i] = SColorText();
+					bsNormal.monocolor[i] = SColorText();
+					bsOk.textcolor[i] = SColorText();
+					bsScroll.monocolor[i] = SColorText();
+				}
+				bsNormal.textcolor[3] = SColorDisabled();
+				bsNormal.monocolor[3] = SColorText();
+				bsOk.textcolor[3] = SColorDisabled();
+				bsScroll.monocolor[3] = SColorText();
+*/
+				//st.monocolor[0] = st.monocolor[1] = st.monocolor[2] = st.monocolor[3] = SColorFace();
+				//Blend(Blend(SColorText, SColorShadow), SColorLabel, 80);
+				//st.textcolor[0] = st.textcolor[1] = st.textcolor[2] = SColorLabel();
+				//st.textcolor[3] = SColorDisabled();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+/*
+				bsNormal = bsNormal.Standard();
+				bsOk = bsOk.Standard();
+				bsScroll = bsScroll.Standard();
+				bsEdge = bsEdge.Standard();
+*/
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		ButtonOption::Style& st = ButtonOption::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		SpinButtons::Style& st = SpinButtons::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		EditField::Style& st = EditField::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+				//st.focus = Blend(Green(), Black(), BLENDIT/2);
+		/*
+				st.paper = SColorPaper();
+				st.disabled = SColorFace();
+				st.invalid = Blend(es.paper, Blue(), BLENDIT/5);
+				st.text = SColorText();
+				st.textdisabled = SColorDisabled();
+				st.selected = SColorHighlight();
+				st.selectedtext = SColorHighlightText();
+				for(int i = 0; i < 4; i++)
+					st.edge[i] = CtrlsImg::EFE();
+				st.activeedge = false;
+				st.vfm = 2;
+		*/
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+				//st.focus = Blend(Green(), White(), BLENDIT);
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		HeaderCtrl::Style& st = HeaderCtrl::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		DropList::Style& st = DropList::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+	if(1)
+	{
+		TabCtrl::Style& st = TabCtrl::StyleDefault().Write();
+		switch(a)
+		{
+			case 1:
+			{
+				st = st.Standard();
+			}
+				break;
+			default:
+			{
+				st = st.Standard();
+			}
+				break;
+		}
+	}
+
+}
--- a/bazaar/StylerTest/AllCtrlTest.iml
+++ b/bazaar/StylerTest/AllCtrlTest.iml
@ -0,0 +1,8 @@
+PREMULTIPLIED
+IMAGE_ID(icon)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,99,16,96,16,96,160,17,248,143,132,201,213,139,206,38,69,63,46,183,16,99,30,46,253,184,228,137,113,15,46)
+IMAGE_DATA(253,196,186,133,82,253,196,152,133,79,47,186,126,98,194,18,151,126,98,0,54,181,196,234,39,197,77,184,212,224,82,71)
+IMAGE_DATA(170,31,72,73,119,3,10,0,196,28,48,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(96, 1)
--- a/bazaar/StylerTest/AllCtrlTest.lay
+++ b/bazaar/StylerTest/AllCtrlTest.lay
@ -0,0 +1,49 @@
+LAYOUT(AllCtrlTestLayout, 768, 640)
+	ITEM(DocEdit, de, Tip(t_("DocEdit")).LeftPosZ(0, 152).TopPosZ(0, 44))
+	ITEM(LineEdit, le, Tip(t_("LineEdit")).LeftPosZ(0, 152).TopPosZ(48, 19))
+	ITEM(EditField, ef, Tip(t_("EditField")).LeftPosZ(0, 152).TopPosZ(72, 19))
+	ITEM(EditString, es, Tip(t_("EditString")).LeftPosZ(0, 152).TopPosZ(96, 19))
+	ITEM(Button, b, SetLabel(t_("Button")).Tip(t_("Button")).LeftPosZ(156, 56).TopPosZ(0, 20))
+	ITEM(Option, o, SetLabel(t_("Option")).Tip(t_("Option")).LeftPosZ(156, 56).TopPosZ(24, 16))
+	ITEM(Switch, sw, SetLabel(t_("Switch\nother")).LeftPosZ(156, 56).TopPosZ(48, 44))
+	ITEM(ButtonOption, bo, LeftPosZ(156, 56).TopPosZ(96, 20))
+	ITEM(DataPusher, dp, Tip(t_("DataPusher")).LeftPosZ(216, 92).TopPosZ(0, 20))
+	ITEM(SliderCtrl, sl, LeftPosZ(216, 92).TopPosZ(24, 20))
+	ITEM(Label, l, SetLabel(t_("Label")).LeftPosZ(312, 64).TopPosZ(0, 19))
+	ITEM(LabelBox, lb, SetLabel(t_("LabelBox")).LeftPosZ(312, 64).TopPosZ(24, 92))
+	ITEM(StaticText, st, SetText(t_("StaticText")).LeftPosZ(216, 92).TopPosZ(96, 19))
+	ITEM(RichTextCtrl, rtc, LeftPosZ(216, 92).TopPosZ(48, 19))
+	ITEM(EditInt, ei, Tip(t_("EditInt")).LeftPosZ(0, 76).TopPosZ(124, 19))
+	ITEM(EditInt64, ei64, Tip(t_("EditInt64")).LeftPosZ(0, 76).TopPosZ(144, 19))
+	ITEM(EditDouble, ed, Tip(t_("EditDouble")).LeftPosZ(0, 76).TopPosZ(164, 19))
+	ITEM(EditIntNotNull, einn, Tip(t_("EditIntNotNull")).LeftPosZ(76, 76).TopPosZ(124, 19))
+	ITEM(EditInt64NotNull, ei64nn, LeftPosZ(76, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleNotNull, ednn, Tip(t_("EditDoubleNotNull")).LeftPosZ(76, 76).TopPosZ(164, 19))
+	ITEM(EditIntSpin, eis, Tip(t_("EditIntSpin")).LeftPosZ(156, 76).TopPosZ(124, 19))
+	ITEM(EditInt64Spin, ei64s, LeftPosZ(156, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleSpin, eds, Tip(t_("EditDoubleSpin")).LeftPosZ(156, 76).TopPosZ(164, 19))
+	ITEM(EditIntNotNullSpin, einns, LeftPosZ(236, 72).TopPosZ(124, 19))
+	ITEM(EditInt64NotNullSpin, ei64nns, LeftPosZ(236, 72).TopPosZ(144, 19))
+	ITEM(EditDoubleNotNullSpin, ednns, LeftPosZ(236, 72).TopPosZ(164, 19))
+	ITEM(EditDate, edt, Tip(t_("EditDate")).LeftPosZ(0, 76).TopPosZ(192, 19))
+	ITEM(EditTime, etm, Tip(t_("EditTime")).LeftPosZ(0, 76).TopPosZ(212, 19))
+	ITEM(EditDateNotNull, edtnn, LeftPosZ(76, 76).TopPosZ(192, 19))
+	ITEM(EditTimeNotNull, etmnn, LeftPosZ(76, 76).TopPosZ(212, 19))
+	ITEM(ProgressIndicator, pi, LeftPosZ(380, 76).TopPosZ(344, 20))
+	ITEM(Progress, pr, LeftPosZ(464, 68).TopPosZ(344, 20))
+	ITEM(DropDate, ddt, LeftPosZ(156, 120).TopPosZ(192, 19))
+	ITEM(DropTime, dtm, LeftPosZ(156, 120).TopPosZ(212, 19))
+	ITEM(DropList, dl, LeftPosZ(0, 152).TopPosZ(344, 19))
+	ITEM(ArrayCtrl, ac, LeftPosZ(0, 152).TopPosZ(236, 104))
+	ITEM(RichTextView, rtv, LeftPosZ(216, 92).TopPosZ(72, 19))
+	ITEM(TabCtrl, tb, LeftPosZ(156, 220).TopPosZ(236, 104))
+	ITEM(Clock, clk, LeftPosZ(380, 150).TopPosZ(0, 156))
+	ITEM(Calendar, cl, LeftPosZ(532, 236).TopPosZ(0, 156))
+	ITEM(DropTree, dtr, LeftPosZ(156, 220).TopPosZ(344, 19))
+	ITEM(TreeCtrl, tr, LeftPosZ(380, 152).TopPosZ(160, 180))
+	ITEM(Button, dv___42, LeftPosZ(312, 64).TopPosZ(124, 60))
+	ITEM(StatusBar, stbar, LeftPosZ(0, 768).TopPosZ(616, 23))
+	ITEM(MenuBar, mbar, LeftPosZ(0, 768).TopPosZ(592, 23))
+	ITEM(ToolBar, tool, LeftPosZ(0, 768).TopPosZ(568, 23))
+END_LAYOUT
+
--- a/bazaar/StylerTest/MyCtrls.iml
+++ b/bazaar/StylerTest/MyCtrls.iml
@ -0,0 +1,186 @@
+PREMULTIPLIED
+IMAGE_ID(S0)
+IMAGE_ID(S0h)
+IMAGE_ID(S0p)
+IMAGE_ID(S0d)
+IMAGE_ID(S1)
+IMAGE_ID(S1h)
+IMAGE_ID(S1p)
+IMAGE_ID(S1d)
+IMAGE_ID(O0)
+IMAGE_ID(O0h)
+IMAGE_ID(O0p)
+IMAGE_ID(O0d)
+IMAGE_ID(O1)
+IMAGE_ID(O1h)
+IMAGE_ID(O1p)
+IMAGE_ID(O1d)
+IMAGE_ID(O2)
+IMAGE_ID(O2h)
+IMAGE_ID(O2p)
+IMAGE_ID(O2d)
+IMAGE_ID(B)
+IMAGE_ID(Bh)
+IMAGE_ID(Bp)
+IMAGE_ID(Bd)
+IMAGE_ID(EB)
+IMAGE_ID(EBh)
+IMAGE_ID(EBp)
+IMAGE_ID(EBd)
+IMAGE_ID(SB)
+IMAGE_ID(SBh)
+IMAGE_ID(SBp)
+IMAGE_ID(SBd)
+IMAGE_ID(SBHT)
+IMAGE_ID(SBHTh)
+IMAGE_ID(SBHTp)
+IMAGE_ID(SBHTd)
+IMAGE_ID(SBVT)
+IMAGE_ID(SBVTh)
+IMAGE_ID(SBVTp)
+IMAGE_ID(SBVTd)
+IMAGE_ID(OkB)
+IMAGE_ID(OkBh)
+IMAGE_ID(OkBp)
+IMAGE_ID(OkBd)
+IMAGE_ID(OBlack)
+IMAGE_ID(SBlack)
+IMAGE_ID(SizeGrip)
+IMAGE_ID(kDA)
+IMAGE_ID(kUA)
+IMAGE_ID(kLA)
+IMAGE_ID(kRA)
+IMAGE_ID(kSpU)
+IMAGE_ID(kSpD)
+IMAGE_ID(DA)
+IMAGE_ID(UA)
+IMAGE_ID(LA)
+IMAGE_ID(RA)
+IMAGE_ID(SpU)
+IMAGE_ID(SpD)
+IMAGE_ID(SBVU)
+IMAGE_ID(SBVUh)
+IMAGE_ID(SBVUp)
+IMAGE_ID(SBVUd)
+IMAGE_ID(SBVL)
+IMAGE_ID(SBVLh)
+IMAGE_ID(SBVLp)
+IMAGE_ID(SBVLd)
+IMAGE_ID(SBHU)
+IMAGE_ID(SBHUh)
+IMAGE_ID(SBHUp)
+IMAGE_ID(SBHUd)
+IMAGE_ID(SBHL)
+IMAGE_ID(SBHLh)
+IMAGE_ID(SBHLp)
+IMAGE_ID(SBHLd)
+IMAGE_ID(SBVI)
+IMAGE_ID(SBHI)
+IMAGE_ID(EFE)
+IMAGE_ID(VE)
+IMAGE_ID(HorzPos)
+IMAGE_ID(HorzSplit)
+IMAGE_ID(HTB)
+IMAGE_ID(HTBh)
+IMAGE_ID(HTBp)
+IMAGE_ID(HTBd)
+IMAGE_ID(PI)
+IMAGE_ID(VPI)
+IMAGE_ID(PIC)
+IMAGE_ID(VPIC)
+IMAGE_ID(TAB)
+IMAGE_ID(TABh)
+IMAGE_ID(TABs)
+IMAGE_ID(TABd)
+IMAGE_ID(FTAB)
+IMAGE_ID(FTABh)
+IMAGE_ID(FTABs)
+IMAGE_ID(FTABd)
+IMAGE_ID(LTAB)
+IMAGE_ID(LTABh)
+IMAGE_ID(LTABs)
+IMAGE_ID(LTABd)
+IMAGE_ID(BTAB)
+IMAGE_ID(BTABh)
+IMAGE_ID(BTABs)
+IMAGE_ID(BTABd)
+IMAGE_ID(TABB)
+IMAGE_ID(SLA)
+IMAGE_ID(SRA)
+IMAGE_ID(TB)
+IMAGE_ID(TBh)
+IMAGE_ID(TBp)
+IMAGE_ID(TBd)
+IMAGE_ID(TB1)
+IMAGE_ID(TB1h)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,152,75,110,195,48,12,68,5,20,69,27,160,222,116,145,243,230,104,61,74,143,18,39,128,1,47,200,225,7)
+IMAGE_DATA(132,101,201,243,180,147,57,148,68,81,12,145,182,180,165,125,172,227,182,142,23,143,0,81,123,66,246,100,242,173,245,78)
+IMAGE_DATA(216,127,128,102,111,249,163,166,70,179,205,71,238,39,194,101,18,214,130,154,26,77,230,126,34,12,153,176,127,0,205,222)
+IMAGE_DATA(242,71,77,141,102,155,143,220,79,132,33,19,182,242,197,87,86,23,106,114,247,19,33,157,176,159,235,248,90,199,40,9)
+IMAGE_DATA(107,249,67,115,146,127,164,209,246,117,6,77,230,60,26,40,222,26,200,159,7,86,88,69,71,13,43,108,106,65,137,163)
+IMAGE_DATA(123,88,201,63,210,104,251,58,131,38,115,30,13,20,111,13,228,207,195,144,21,150,92,151,33,19,54,243,19,101,249,163)
+IMAGE_DATA(134,61,108,201,130,18,153,132,181,160,102,242,30,150,255,195,82,195,30,214,73,229,139,175,172,46,212,228,238,39,194,144)
+IMAGE_DATA(255,18,100,2,104,249,67,115,146,127,164,209,246,117,6,77,230,60,26,40,222,26,200,159,7,86,88,69,71,13,43,108)
+IMAGE_DATA(106,65,137,163,123,88,201,63,210,104,251,58,131,38,115,30,13,20,111,13,228,207,195,144,9,91,249,226,61,213,197,51)
+IMAGE_DATA(191,255,134,246,208,91,147,57,79,36,110,150,78,178,143,112,153,150,192,242,71,13,123,216,146,5,37,50,9,107,65,205)
+IMAGE_DATA(228,21,118,180,30,214,2,105,60,243,251,111,104,15,189,53,153,243,68,226,102,233,36,251,8,169,132,253,105,247,119,133)
+IMAGE_DATA(253,110,191,161,132,173,72,86,66,72,63,162,239,189,91,177,136,182,4,200,15,237,105,63,179,253,54,239,125,47,94,166)
+IMAGE_DATA(45,22,8,218,211,126,102,123,164,145,108,189,68,223,251,19,159,211,90,105,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(416, 23)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,153,93,106,66,65,12,70,3,133,82,68,138,136,148,46,183,75,115,41,93,74,171,56,111,185,153,47,83,188)
+IMAGE_DATA(243,211,115,124,11,231,139,40,38,14,115,237,104,31,246,242,251,122,179,179,221,248,18,201,184,30,215,13,182,220,168,15)
+IMAGE_DATA(62,254,202,126,169,171,243,162,146,157,119,123,183,207,251,178,56,216,37,181,44,90,222,16,0,96,116,90,247,224,48,203)
+IMAGE_DATA(244,187,194,86,70,233,75,142,28,185,249,115,165,30,81,235,171,240,111,151,169,2,57,114,228,230,207,41,89,47,147,101)
+IMAGE_DATA(250,101,186,117,231,17,221,125,40,119,34,217,59,25,114,228,200,141,153,43,245,136,90,95,133,230,101,58,203,3,150,204)
+IMAGE_DATA(23,136,143,191,146,31,101,60,87,37,253,128,165,215,178,200,30,93,163,62,248,248,43,251,165,174,206,139,202,178,203,34)
+IMAGE_DATA(2,31,127,101,63,202,120,174,202,52,203,34,123,4,139,250,224,227,175,236,151,186,58,47,42,233,101,113,120,44,139,87)
+IMAGE_DATA(113,89,180,46,9,229,67,170,95,8,30,222,51,60,207,245,156,26,234,28,237,54,124,234,209,133,26,181,94,181,82,255)
+IMAGE_DATA(235,177,121,218,225,243,192,195,219,195,243,92,207,169,49,220,240,169,127,249,212,168,245,170,149,250,110,199,206,163,93,30)
+IMAGE_DATA(23,68,167,161,47,136,34,240,241,123,250,81,198,115,85,26,110,123,251,12,115,246,104,17,245,193,199,239,233,151,186,250)
+IMAGE_DATA(123,86,89,118,152,35,240,241,123,250,81,198,115,85,178,243,248,3,17,30,80,110,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(352, 16)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,90,75,110,219,48,16,165,107,27,182,19,23,104,139,52,119,232,125,122,158,32,87,9,178,235,58,5,178,236)
+IMAGE_DATA(33,186,236,162,237,69,212,25,87,20,40,122,126,148,162,47,230,13,12,219,228,227,227,227,152,36,72,219,225,28,238,194)
+IMAGE_DATA(22,226,24,62,4,196,163,17,37,92,10,63,24,112,92,73,199,249,206,159,146,31,203,173,243,217,138,210,245,24,206,225)
+IMAGE_DATA(190,94,204,159,70,93,204,14,135,99,90,44,102,179,248,205,128,227,74,58,206,119,254,154,249,177,220,186,94,172,88,237)
+IMAGE_DATA(102,33,193,249,206,95,51,95,106,67,113,173,88,204,102,81,114,7,155,219,29,210,249,206,31,147,31,203,173,235,197,138)
+IMAGE_DATA(226,205,226,61,196,6,226,22,194,225,152,61,124,194,58,22,133,51,196,144,120,125,121,174,94,95,158,170,34,254,119,59)
+IMAGE_DATA(31,81,1,202,157,9,253,39,126,53,255,209,111,244,96,241,159,251,237,227,95,243,75,190,39,252,150,248,167,240,247,207)
+IMAGE_DATA(175,42,28,194,174,41,224,206,15,8,174,62,21,228,202,211,250,86,65,218,185,72,84,58,40,49,220,212,239,160,123,173)
+IMAGE_DATA(115,179,24,99,142,51,219,234,156,27,13,55,106,171,17,54,155,123,184,203,73,163,182,118,218,18,210,220,144,105,136,56)
+IMAGE_DATA(49,159,133,132,171,97,101,229,82,199,146,65,75,59,170,158,211,47,242,47,37,194,34,104,53,54,84,98,36,159,154,255)
+IMAGE_DATA(22,14,144,10,14,165,153,127,171,242,49,235,155,55,84,34,166,52,54,86,130,175,10,251,236,90,173,215,212,174,197,189)
+IMAGE_DATA(166,58,104,222,124,132,91,67,68,159,59,118,115,127,118,65,23,236,32,184,1,73,23,116,193,169,5,143,16,248,59,193)
+IMAGE_DATA(174,62,214,179,196,194,14,227,70,44,213,113,28,173,94,211,231,160,141,15,82,113,170,147,177,95,76,50,38,75,22,38)
+IMAGE_DATA(106,83,7,101,34,47,131,156,238,195,187,58,56,101,106,36,169,160,196,187,114,121,7,139,229,4,31,234,141,112,46,141)
+IMAGE_DATA(168,50,168,13,12,122,248,20,165,215,166,199,124,185,66,234,105,250,84,206,53,61,78,51,182,235,224,79,109,67,204,17)
+IMAGE_DATA(83,93,174,213,247,65,105,246,245,55,68,254,210,250,82,61,78,43,107,95,226,175,8,146,94,23,44,65,47,155,31,50)
+IMAGE_DATA(238,97,115,189,129,205,245,182,195,230,106,238,196,160,155,202,135,55,78,238,92,117,165,5,200,233,90,22,84,87,93,78)
+IMAGE_DATA(91,241,98,241,203,150,7,102,90,81,186,20,39,213,78,203,164,71,222,94,227,14,229,119,200,252,166,245,93,117,57,205)
+IMAGE_DATA(76,167,139,223,34,88,116,187,96,137,186,204,188,146,177,133,35,251,6,142,235,248,64,104,23,3,234,2,81,36,68,157)
+IMAGE_DATA(231,167,21,82,135,118,128,216,214,129,200,239,61,151,187,79,82,158,187,236,122,113,179,212,113,253,73,62,215,55,32,60)
+IMAGE_DATA(164,196,159,104,112,218,255,100,34,226,27,19,17,15,76,68,124,101,34,226,11,19,205,178,100,194,218,94,235,95,243,175)
+IMAGE_DATA(141,95,202,31,164,250,120,153,67,210,190,67,1,5,176,19,52,130,102,113,64,56,104,124,198,247,88,142,245,177,179,181)
+IMAGE_DATA(114,75,0,71,239,207,245,23,86,252,215,130,249,158,78,45,175,148,199,213,167,60,231,56,103,14,156,193,23,0,245,223)
+IMAGE_DATA(253,148,147,214,165,175,157,227,156,49,56,151,191,26,252,63,170,237,201,9,174,77,124,203,74,163,58,159,91,221,63,131)
+IMAGE_DATA(98,165,116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(800, 53)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,237,150,77,22,131,32,12,132,83,173,181,93,246,207,243,218,155,121,148,30,165,145,106,95,196,4,217,168,188,50)
+IMAGE_DATA(195,198,38,159,2,101,128,208,133,158,84,114,59,210,149,70,181,158,200,147,159,247,57,25,235,6,249,156,204,107,207,96)
+IMAGE_DATA(192,108,193,208,218,27,192,226,192,128,73,129,89,125,3,188,7,89,131,147,57,249,12,6,204,22,12,213,188,5,74,215)
+IMAGE_DATA(42,213,224,75,198,143,217,105,90,231,169,229,86,63,9,80,11,130,73,153,65,45,8,38,107,6,181,32,152,172,25,212)
+IMAGE_DATA(130,131,80,11,130,201,154,65,45,8,38,107,6,181,32,152,172,25,212,130,131,80,11,130,201,154,225,147,160,166,3,183)
+IMAGE_DATA(138,91,251,7,162,19,79,200,82,63,123,45,230,199,59,33,45,22,195,135,190,63,27,143,63,232,208,11,161,78,66,3)
+IMAGE_DATA(179,38,19,251,253,217,96,122,219,140,114,127,253,153,26,42,184,85,116,255,5,213,53,162,233,53,37,37,57,237,36,183)
+IMAGE_DATA(174,53,228,145,215,98,150,191,150,252,201,91,242,107,230,210,48,179,102,226,152,142,17,79,51,46,115,227,111,107,221,39)
+IMAGE_DATA(71,223,139,197,71,94,227,188,82,208,109,230,150,144,213,160,125,164,173,145,187,191,250,149,61,209,35,250,254,130,160,61)
+IMAGE_DATA(180,228,207,15,83,134,94,234,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(320, 22)
--- a/bazaar/StylerTest/StylerTest.h
+++ b/bazaar/StylerTest/StylerTest.h
@ -0,0 +1,36 @@
+#ifndef _StylerTest_StylerTest_h
+#define _StylerTest_StylerTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#include <Styler/Styler.h>
+
+#define LAYOUTFILE <StylerTest/StylerTest.lay>
+#include <CtrlCore/lay.h>
+
+#define IMAGECLASS StylerTestImg
+#define IMAGEFILE <StylerTest/StylerTest.iml>
+#include <Draw/iml_header.h>
+
+class StylerTest : public WithStylerTestLayout<TopWindow> {
+public:
+	typedef StylerTest CLASSNAME;
+	StylerTest();
+
+	void ChangeStyle();
+	void InvertColors();
+	void ColorizedSkin();
+
+	void ReloadChamCB();
+	void ReloadCB();
+	void Menu(Bar& bar);
+
+	Array<Ctrl> arc;
+	StylerCtrl sc;
+	ChamStyleCtrl chc;
+};
+
+#endif
+
--- a/bazaar/StylerTest/StylerTest.iml
+++ b/bazaar/StylerTest/StylerTest.iml
@ -0,0 +1,8 @@
+PREMULTIPLIED
+IMAGE_ID(icon)
+
+IMAGE_BEGIN_DATA
+IMAGE_DATA(120,156,99,16,96,16,96,160,17,248,143,132,201,213,139,206,38,69,63,46,183,16,99,30,46,253,184,228,137,113,15,46)
+IMAGE_DATA(253,196,186,133,82,253,196,152,133,79,47,186,126,98,194,18,151,126,98,0,54,181,196,234,39,197,77,184,212,224,82,71)
+IMAGE_DATA(170,31,72,73,119,3,10,0,196,28,48,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
+IMAGE_END_DATA(96, 1)
--- a/bazaar/StylerTest/StylerTest.lay
+++ b/bazaar/StylerTest/StylerTest.lay
@ -0,0 +1,49 @@
+LAYOUT(StylerTestLayout, 768, 640)
+	ITEM(DocEdit, de, Tip(t_("DocEdit")).LeftPosZ(0, 152).TopPosZ(0, 44))
+	ITEM(LineEdit, le, Tip(t_("LineEdit")).LeftPosZ(0, 152).TopPosZ(48, 19))
+	ITEM(EditField, ef, Tip(t_("EditField")).LeftPosZ(0, 152).TopPosZ(72, 19))
+	ITEM(EditString, es, Tip(t_("EditString")).LeftPosZ(0, 152).TopPosZ(96, 19))
+	ITEM(Button, b, SetLabel(t_("Button")).Tip(t_("Button")).LeftPosZ(156, 56).TopPosZ(0, 20))
+	ITEM(Option, o, SetLabel(t_("Option")).Tip(t_("Option")).LeftPosZ(156, 56).TopPosZ(24, 16))
+	ITEM(Switch, sw, SetLabel(t_("Switch\nother")).LeftPosZ(156, 56).TopPosZ(48, 44))
+	ITEM(ButtonOption, bo, LeftPosZ(156, 56).TopPosZ(96, 20))
+	ITEM(DataPusher, dp, Tip(t_("DataPusher")).LeftPosZ(216, 92).TopPosZ(0, 20))
+	ITEM(SliderCtrl, sl, LeftPosZ(216, 92).TopPosZ(24, 20))
+	ITEM(Label, l, SetLabel(t_("Label")).LeftPosZ(312, 64).TopPosZ(0, 19))
+	ITEM(LabelBox, lb, SetLabel(t_("LabelBox")).LeftPosZ(312, 64).TopPosZ(24, 92))
+	ITEM(StaticText, st, SetText(t_("StaticText")).LeftPosZ(216, 92).TopPosZ(96, 19))
+	ITEM(RichTextCtrl, rtc, LeftPosZ(216, 92).TopPosZ(48, 19))
+	ITEM(EditInt, ei, Tip(t_("EditInt")).LeftPosZ(0, 76).TopPosZ(124, 19))
+	ITEM(EditInt64, ei64, Tip(t_("EditInt64")).LeftPosZ(0, 76).TopPosZ(144, 19))
+	ITEM(EditDouble, ed, Tip(t_("EditDouble")).LeftPosZ(0, 76).TopPosZ(164, 19))
+	ITEM(EditIntNotNull, einn, Tip(t_("EditIntNotNull")).LeftPosZ(76, 76).TopPosZ(124, 19))
+	ITEM(EditInt64NotNull, ei64nn, LeftPosZ(76, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleNotNull, ednn, Tip(t_("EditDoubleNotNull")).LeftPosZ(76, 76).TopPosZ(164, 19))
+	ITEM(EditIntSpin, eis, Tip(t_("EditIntSpin")).LeftPosZ(156, 76).TopPosZ(124, 19))
+	ITEM(EditInt64Spin, ei64s, LeftPosZ(156, 76).TopPosZ(144, 19))
+	ITEM(EditDoubleSpin, eds, Tip(t_("EditDoubleSpin")).LeftPosZ(156, 76).TopPosZ(164, 19))
+	ITEM(EditIntNotNullSpin, einns, LeftPosZ(236, 72).TopPosZ(124, 19))
+	ITEM(EditInt64NotNullSpin, ei64nns, LeftPosZ(236, 72).TopPosZ(144, 19))
+	ITEM(EditDoubleNotNullSpin, ednns, LeftPosZ(236, 72).TopPosZ(164, 19))
+	ITEM(EditDate, edt, Tip(t_("EditDate")).LeftPosZ(0, 76).TopPosZ(192, 19))
+	ITEM(EditTime, etm, Tip(t_("EditTime")).LeftPosZ(0, 76).TopPosZ(212, 19))
+	ITEM(EditDateNotNull, edtnn, LeftPosZ(76, 76).TopPosZ(192, 19))
+	ITEM(EditTimeNotNull, etmnn, LeftPosZ(76, 76).TopPosZ(212, 19))
+	ITEM(ProgressIndicator, pi, LeftPosZ(380, 76).TopPosZ(344, 20))
+	ITEM(Progress, pr, LeftPosZ(464, 68).TopPosZ(344, 20))
+	ITEM(DropDate, ddt, LeftPosZ(156, 120).TopPosZ(192, 19))
+	ITEM(DropTime, dtm, LeftPosZ(156, 120).TopPosZ(212, 19))
+	ITEM(DropList, dl, LeftPosZ(0, 152).TopPosZ(344, 19))
+	ITEM(ArrayCtrl, ac, LeftPosZ(0, 152).TopPosZ(236, 104))
+	ITEM(RichTextView, rtv, LeftPosZ(216, 92).TopPosZ(72, 19))
+	ITEM(TabCtrl, tb, LeftPosZ(156, 220).TopPosZ(236, 104))
+	ITEM(Clock, clk, LeftPosZ(380, 150).TopPosZ(0, 156))
+	ITEM(Calendar, cl, LeftPosZ(532, 236).TopPosZ(0, 156))
+	ITEM(DropTree, dtr, LeftPosZ(156, 220).TopPosZ(344, 19))
+	ITEM(TreeCtrl, tr, LeftPosZ(380, 152).TopPosZ(160, 180))
+	ITEM(Button, dv___42, LeftPosZ(312, 64).TopPosZ(124, 60))
+	ITEM(StatusBar, stbar, LeftPosZ(0, 768).TopPosZ(616, 23))
+	ITEM(MenuBar, mbar, LeftPosZ(0, 768).TopPosZ(592, 23))
+	ITEM(ToolBar, tool, LeftPosZ(0, 768).TopPosZ(568, 23))
+END_LAYOUT
+
--- a/bazaar/StylerTest/StylerTest.upp
+++ b/bazaar/StylerTest/StylerTest.upp
@ -0,0 +1,15 @@
+description "Style changing playground\377";
+
+uses
+	CtrlLib,
+	Styler;
+
+file
+	StylerTest.h,
+	main.cpp,
+	StylerTest.lay,
+	StylerTest.iml;
+
+mainconfig
+	"" = "GUI MT";
+
--- a/bazaar/StylerTest/init
+++ b/bazaar/StylerTest/init
@ -0,0 +1,5 @@
+#ifndef _StylerTest_icpp_init_stub
+#define _StylerTest_icpp_init_stub
+#include "CtrlLib/init"
+#include "Styler/init"
+#endif
--- a/bazaar/StylerTest/main.cpp
+++ b/bazaar/StylerTest/main.cpp
@ -0,0 +1,122 @@
+#include "StylerTest.h"
+
+#define IMAGECLASS StylerTestImg
+#define IMAGEFILE <StylerTest/StylerTest.iml>
+#include <Draw/iml_source.h>
+
+void StylerTest::ReloadChamCB()
+{
+	chc.Reload();	
+}
+
+void StylerTest::ReloadCB()
+{
+	Refresh();	
+}
+
+void StylerTest::Menu(Bar& bar)
+{
+	bar.Add(true, "Refresh", CtrlImg::help(), THISBACK(ReloadCB));
+	bar.Add(false, "Refresh(dis)", CtrlImg::help(), THISBACK(ReloadCB));
+}
+
+StylerTest::StylerTest()
+{
+	CtrlLayout(*this, "Window title");
+
+	Add(sc.LeftPos(0,200).BottomPos(0,200));
+	sc <<= THISBACK(ReloadChamCB);
+
+	Add(chc.RightPos(0,400).BottomPos(0,200));
+
+	mbar.Set( THISBACK( Menu ) );
+	tool.Set( THISBACK( Menu ) );
+
+	AddFrame(mbar);
+	AddFrame(tool);
+	AddFrame(stbar);
+
+	//dummys
+
+	bo.SetLabel("But.Opt.");
+	
+	de.SetData("This is a\nDocEdit example text");
+	le.SetData("LineEdit");
+	ef.SetData("EditField");
+	es.SetData("EditString");
+	
+	ei = 100;
+	ei64 = 22342599399929;
+	ed = 10.3;
+	
+	einn <<= 100;
+	ei64nn <<= 22342599399929;
+	ednn <<= 10.3;
+
+	eis <<= 100;
+	ei64s <<= 22342599399929;
+	eds <<= 10.3;
+
+	einns <<= 100;
+	ei64nns <<= 22342599399929;
+	ednns <<= 10.3;
+	
+	edt <<= GetSysDate();
+	etm <<= GetSysTime();
+
+	edtnn <<= GetSysDate();
+	etmnn <<= GetSysTime();
+
+	ddt <<= GetSysDate();
+	dtm <<= GetSysTime();
+	
+	ac.AddColumn("One");
+	ac.AddColumn("Two");
+	ac.Add("Hello", 1234);
+	ac.Add(23.8, "servus");
+	ac.Add("foo", true);
+	ac.Add("bar", "lee");
+
+	sl <<= 0;
+	
+	dl.Add(0,"First");
+	dl.Add(1,"Second");
+	dl.Add(2,"Third");
+	dl.Add(3,"Fourth");
+	
+	
+	Vector<int> parent, parent2;
+	parent.Add(0);
+	tr.SetRoot(Image(), "The Tree");
+	for(int i = 1; i < 10000; i++) {
+		parent.Add(tr.Add(parent[rand() % parent.GetCount()], Image(),
+		            FormatIntRoman(i, true)));
+		if((rand() & 3) == 0)
+			tr.Open(parent.Top());
+	}
+	tr.Open(0);
+
+	{
+	TreeCtrl& tree = dtr->MultiSelect();
+	Vector<int> parent, parent2;
+	parent.Add(0);
+	tree.SetRoot(Image(), "The Tree");
+	for(int i = 1; i < 10000; i++) {
+		parent.Add(tree.Add(parent[rand() % parent.GetCount()], Image(),
+		            FormatIntRoman(i, true)));
+		if((rand() & 3) == 0)
+			tree.Open(parent.Top());
+	}
+	tree.Open(0);
+	}
+	
+	tb.Add(arc.Add(new EditString()).SizePos(),"First");
+	tb.Add(arc.Add(new EditString()).SizePos(),"Second");
+	tb.Add(arc.Add(new EditString()).SizePos(),"Third");
+}
+
+GUI_APP_MAIN
+{
+	StylerTest().Run();
+}
+
--- a/bazaar/ValueCtrl/ValueCtrl.cpp
+++ b/bazaar/ValueCtrl/ValueCtrl.cpp
@ -0,0 +1,165 @@
+#include "ValueCtrl.h"
+
+Ctrl* DefaultValueEditor(int vtype)
+{
+	String t;
+	Ctrl* p = NULL;
+	switch(vtype)
+	{
+		case INT_V: p = new EditInt(); break;
+		case DOUBLE_V: p = new EditDouble(); break;
+		case STRING_V: p = new EditString(); break;
+		case DATE_V: p = new DropDate(); break;
+		case TIME_V: p = new DropTime(); break;
+		case WSTRING_V: p = new RichTextCtrl(); break;
+		case INT64_V: p = new EditInt64(); break;
+		case BOOL_V: { Option* _p = new Option(); _p->ClickFocus(); p = _p; } break;
+		
+		case COLOR_V: p = new ColorPusher(); break;
+		//case FONT_V: p = new FontPusher(); break; //FIXME
+
+		case LOGPOS_V: p = new LogPosCtrl(); break;
+		case VALUE_V: p = new ValuePacker; break;
+		case VALUEARRAY_V:  p = new ValueArrayCtrl(); break;
+		
+		case VOID_V: p = new ValueCtrl(); break;
+
+		case VALUEMAP_V: t = "VALUEMAP_V"; break;
+		
+		case ERROR_V: t = "ERROR_V"; break;
+		case UNKNOWN_V: t = "UNKNOWN_V"; break;
+		default: break;
+	}
+	if(!p)
+	{
+		StaticText* _p = new StaticText();
+		_p->SetText(t);
+		p = _p;
+	}
+	return p;
+}
+
+Ctrl* DefaultValueEditor(const Value& v)
+{
+	Ctrl* p = DefaultValueEditor(v.GetType());
+	p->SetData(v);
+	return p;
+}
+
+void ValuePopUp::SetType(int _vt)
+{
+	if(_vt == vtype) return;
+	v = Value(); //reset
+	if(_vt==VOID_V) //prevent loop
+	{
+		if(pc) return;
+		_vt = STRING_V; //default, if no editor yet
+	}
+	pc = DefaultValueEditor(_vt);
+	vtype = _vt;
+	ASSERT(pc);	
+	Add(pc->HSizePos().VSizePos(0,20));
+	pc->WhenAction = THISBACK(DataAction);
+	WhenTypeChange;
+}
+
+void ValuePopUp::Updated()
+{
+	int _vt = v.GetType();
+	if(_vt != vtype && !v.IsNull())
+		SetType(_vt);
+	if(type.GetData() != vtype)
+	   type.SetData(vtype);
+	pc->SetData(v);
+}
+
+void ValuePopUp::TypeAction()
+{
+	int t = type.GetData();
+	SetType(t);
+	UpdateAction();
+}
+
+ValuePopUp::ValuePopUp()
+	: vtype(-1)
+{
+	CtrlLayout(*this);
+	SetFrame(BlackFrame());
+
+	type.Add(int(VOID_V), "VOID_V (reset data only)");
+	type.Add(int(INT_V), "INT_V");
+	type.Add(int(DOUBLE_V), "DOUBLE_V");
+	type.Add(int(STRING_V), "STRING_V");
+	type.Add(int(DATE_V), "DATE_V");
+	type.Add(int(TIME_V), "TIME_V");
+	type.Add(int(WSTRING_V), "WSTRING_V");
+	type.Add(int(INT64_V), "INT64_V");
+	type.Add(int(BOOL_V), "BOOL_V");
+	type.Add(int(COLOR_V), "COLOR_V");
+	type.Add(int(LOGPOS_V), "LOGPOS_V");
+	//type.Add(int(VALUE_V), "VALUE_V");
+	type.Add(int(VALUEARRAY_V), "VALUEARRAY_V");
+	type <<= THISBACK(TypeAction);
+
+	ok <<= THISBACK(Acceptor);
+	cancel <<= THISBACK(Rejector);
+	
+	SetType(VOID_V);
+}
+
+ValueCtrl::ValueCtrl() 
+	: push(false)
+{
+	IgnoreMouse(false);
+	SetFrame(BlackFrame());
+
+	vp.WhenSelect = THISBACK(AcceptDrop);
+	vp.WhenCancel = THISBACK(CloseDrop);
+	vp.WhenAction = THISBACK(ActionDrop);
+	
+	Update();
+}
+
+void ValueCtrl::LeftDown(Point p, dword keyflags)
+{
+	if(!HasFocus()) SetFocus();
+	Drop();	
+}
+
+void ValueCtrl::Drop()
+{
+	if(push) return;
+	push = true;
+	vs = v;
+	vp.PopUp(this, v);
+}
+
+void ValueCtrl::CloseDrop()
+{
+	push = false;
+	if(v != vs) {
+		v = vs;
+		UpdateAction();
+	}
+}
+
+void ValueCtrl::AcceptDrop()
+{
+	push = false;
+	v = vp.GetData();
+	UpdateAction();
+}
+
+void ValueCtrl::ActionDrop()
+{
+	v = vp.GetData();
+	UpdateAction();
+}
+
+void ValueCtrl::Updated()
+{
+	if(v.IsNull())
+		SetText("#Nil#");
+	else
+		SetText(v.ToString());
+}
--- a/Show more
+++ b/Show more