void Ctrl::SetProperty(const String& name, const Value& v);
void Ctrl::GetProperty(const String& name, Value& v);

c.SetProperty("background", Black);
c.GetProperty("background", v);

c.SetProperty("min", 123);
c.GetProperty("max", v);

c.SetProperty("xalign", "left");
c.SetProperty("xpos", 123);
c.SetProperty("yalign", "center");
c.SetProperty("ypos", 45);

c.SetProperty("pattern", "%.g");
c.SetProperty("grid" ValueArray(Vector<int>() << 5 << 6));

//would map to GetData / SetData directly i.e.
c.SetProperty("data", 345);
c.GetProperty("data", v);

c.GetProperty("count", v);

c.SetProperty("enable", true);
c.GetProperty("enable, v);

c.SetProperty("show", false);
c.SetProperty("title", "MyTitle");
c.SetProperty("tip", "GoHelp");

//query all getable properties
c.GetProperty("rprops", v);
//query all setable properties
c.GetProperty("wprops", v);

..
and many more..

CTRL_PROPERTIES(EditInt)
    PROPERTY(int, Min)
    PROPERTY_SET(bool, "NotNull", NotNull)
    PROPERTY_GET(bool, "NotNull", IsNotNull)
END_CTRL_PROPERTIES

	bool    IsInitFocus() const                { return initfocus; }

	int     GetBackPaint() const               { return backpaint; }

virtual String Ctrl::PropertyHook() const { return "Upp::Ctrl"; }

virtual String EditInt::PropertyHook() const { return "Upp::EditInt"; }

#define HASPROPERTY \
virtual String PropertyHook() const { return String(typeid(CLASSNAME).name()); }

CTRL_PROPERTIES(EditInt)
    PROPERTY(int, Min)
    PROPERTY_SET(bool, "NotNull", NotNull)
    PROPERTY_GET(bool, "NotNull", IsNotNull)
END_CTRL_PROPERTIES

static void GetSet_uniquebyline(Ctrl& c, Value& v, const String& prop, bool set)
{
   EditInt *c = dynamic_cast<EditInt>(&x);
   if(!c) return;
   if(prop == "Min" && set)
      c->Min(v);
   if(prop == "Min" && !set)
      v = c->GetMin();
   ....
}

INITBLOCK { RegisterCtrlGetSet(GetSet_uniquebyline); }

//needs type information to go forward 
//and access the corresponding properties table
template<class C>
void SetProp(C& c, const String& name, const Value& v);

////

//typeless, will search for type table of properties and
//there for the convenient property
void SetProp(Ctrl& c, const String& name, const Value& v);

//for Ctrl

CTRL_PROPERTIES(Ctrl)
PROPERTY(Ctrl, "data", PropSetData, PropGetData)
PROPERTY(Ctrl, "enable", PropEnable, PropIsEnabled)
PROPERTY(Ctrl, "show", PropShow, PropIsVisible)
PROPERTY(Ctrl, "editable", PropEditable, PropIsEditable)
PROPERTY(Ctrl, "logpos", PropSetLogPos, PropGetLogPos)
PROPERTY(Ctrl, "focus", PropFocus, PropHasFocus)
PROPERTY(Ctrl, "modify", PropModify, PropIsModified)
PROPERTY(Ctrl, "tip", PropSetTip, PropGetTip)
PROPERTY(Ctrl, "wantfocus", PropWantFocus, PropIsWantFocus)
PROPERTY(Ctrl, "initFocus", PropInitFocus, PropIsInitFocus)
PROPERTY(Ctrl, "backpaint", PropBackPaint, PropIsBackPaint)
PROPERTY(Ctrl, "transparent", PropTransparent, PropIsTransparent)
PROPERTY_SET(Ctrl, "refresh", PropRefresh)
END_CTRL_PROPERTIES(Ctrl, RecurseDone)

//for EditInt

DEC_CTRL_PROPERTIES(Ctrl)

CTRL_PROPERTIES(EditInt)
PROPERTY(EditInt, "min", PropSetMin, PropGetMin)
PROPERTY(EditInt, "max", PropSetMax, PropGetMax)
END_CTRL_PROPERTIES(EditInt, Ctrl)

PROPERTY(Ctrl, "data", MyPropSetData, MyPropGetData)

class EditIntNotNullSpin : public EditIntSpin
{
public:
	EditIntNotNullSpin(int inc = 1) : EditIntSpin(inc) { NotNull(); }
	EditIntNotNullSpin(int min, int max, int inc = 1) : EditIntSpin(min, max, inc) { NotNull(); }
};

	EditIntSpin(int inc = 1);
	EditIntSpin(int min, int max, int inc = 1);

void EditIntSpin::Init()
{
	sb.inc.WhenAction = sb.inc.WhenRepeat = callback(this, &EditIntSpin::Inc);
	sb.dec.WhenAction = sb.dec.WhenRepeat = callback(this, &EditIntSpin::Dec);
	AddFrame(sb);
}

EditIntSpin::EditIntSpin(int inc) : inc(inc) { Init(); }
EditIntSpin::EditIntSpin(int min, int max, int inc) : EditInt(min, max), inc(inc) { Init(); }

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

..

CTRL_PROPERTIES(EditInt, Ctrl)
PROPERTY("min", PropSetMin, PropGetMin)
PROPERTY("max", PropSetMax, PropGetMax)
END_CTRL_PROPERTIES

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))
	{
		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:
				{ PropList& p = Single<PropList>(); p.PopUp(Ctrl::GetActiveWindow(), *ctrl); }
				break;
			case 1:
				{ PropEdit& p = Single<PropEdit>(); p.PopUp(Ctrl::GetActiveWindow(), *ctrl); }
				break;
		}
		return true;
	}
	return false;
}

int FormView::ObjectFromPt(Point p)
{
	if (!IsLayout()) return -1;

	for (int i = GetObjectCount() - 1; i >= 0; --i)
		if (Zoom(Offseted( (*GetObjects())[i].GetRect() )).Contains(p))
			return i;
	return -1;
}

template<class T>
struct Property
{
	typedef Callback1<const T&> S;
	typedef Callback1<T&> G;

	Property(const S& s, const G& g)
		: set(s), get(g) {}

	const T& Set(const T& a) { ASSERT(set); set(a); return a; }
	T Get() const { ASSERT(get); T t; get(t); return t; }

	inline T operator= (const T& a) { return Set(a); }
	inline operator T() const { return Get(); }

public:
	const S set;
	const G get;
};

typedef Property<Value> PropertyValue;

...

//.h
class PropertyTest : public WithPropertyTestLayout<TopWindow> {
public:
	typedef PropertyTest CLASSNAME;
	PropertyTest();
	
	void GetD(Value& a) { a = "abc"; }
	void SetD(const Value& a) { RLOG(a); }
	
	PropertyValue vp;
};

//.cpp
PropertyTest::PropertyTest()

#pragma warning(push)
#pragma warning(disable:4355)
	: vp( THISBACK(SetD), THISBACK(GetD) )
#pragma warning(pop)

{
	CtrlLayout(*this, "Window title");

	//setting, will call SetD
	vp = 123;

	//getting, will call GetD
	Value v = vp;
	RLOG(v);
}

GUI_APP_MAIN
{
	PropertyTest().Run();
}

EditInt ei;

ei.min = 100;
ei.max = 200;
ei.data = 150;
ei.show = true;
ei.rect = Rect(0,0, 100,200);
...

EditInt ei;

ei.SetMin(100)
  .SetMax(200)
  .SetData(150)
  .Show()
  .SetRect(Rect(0,0, 100,200));