#ifdef PLATFORM_X11
	bool         ignoretakefocus:1;
#endif
	bool		 owned:1; // <--This line

	static  Ptr<Ctrl> eventCtrl;

	// proposed changed, open door for libary developer
	// but still concealed from library user
	//
	bool			IsOwned()const{ return owned; }
	void			SetOwned(bool v=true){ owned=v; }

	// flag: 0 - not to be owned, eg for Ctrl alloc on stack or otherwise maintained
	//       1 - yes, own the child, will be responsible for its destruction
	//       2 or other values - the owned flag has been properly set, just use it.
	void             AddChild(Ctrl *child,int flag=2);
	void             AddChild(Ctrl *child, Ctrl *insafter,int flag=2);
	void             AddChildBefore(Ctrl *child, Ctrl *insbefore, int flag=2);
	// seel RemoveChild0 for explanation of detachOnly parameter
	//
	void            RemoveChild(Ctrl *child, bool detachOnly=false);

	// flag 2 means to leave the owned flag untouched( already properly set)
	void    Add(Ctrl& ctrl, int flag=2)  { AddChild(&ctrl, flag); }

	
	// when a child is removed, it should be delete'd if its @param owned 
	// flag is true. Sometimes we may want to keep it alive and transfer the
	// ownership to some other Ctrl, in this case, we should call the following
	// function with @param detachOnly set to true
	//
	void    RemoveChild0(Ctrl *q, bool detachOnly=false);

struct MyButton : Moveable<MyButton>, Button
{
    // note: alwasy default to false becasue
    // existing U++ user are used to this behaviour
    //
    MyButton(bool toBeOwned=false)
    {
        SetOwned(toBeOwned);
    }

    virtual ~MyButton()
    {
          DUMP("Yes, I am properly destructed!!!");
    }
}; 

class App : public TopWindow
{
public:
    App()
    {
         Button * p=new MyButton(true);
         Button * p2=new MyButton();

         p->SetLabel("Button 1").TopSizeZ(2,20).LeftSize(2, 60);
         p2->SetLabel("Button 2").TopSizeZ(40,20).LeftSize(2, 60);
         Add(*p); // p will be destructed because we SetOwned in
                 // its constructor;
         // or (*this) << p;

         Add(*p2, 1);
    }
};

void  Ctrl::AddChild(Ctrl *q, Ctrl *p, int flag)
{
	GuiLock __;
	ASSERT(q);

	LLOG("Add " << UPP::Name(q) << " to: " << Name());
	if(p == q) return;
	bool updaterect = true;
	bool owned;
	switch(flag)
	{
		default: // note, all value of flag other than 0&1 in this branch
			owned=q->owned;
			break;
		case 0:
		case 1:
			q->owned=flag==1;
	}

	///if(dynamic_cast<q
	
	if(q->parent) {
		ASSERT(!q->inframe);


//************************
// following couple of lines takes care of the issues you raised.
//*************************
		if(q->parent == this) {
			RemoveChild0(q, true); // detach only
			updaterect = false;
		}
		else
			q->parent->RemoveChild(q, true); // detach only	}
	q->parent = this;
	if(p) {
		ASSERT(p->parent == this);
		q->prev = p;
		q->next = p->next;
		if(p == lastchild)
			lastchild = q;
		else
			p->next->prev = q;
		p->next = q;
	}
	else
		if(firstchild) {
			q->prev = NULL;
			q->next = firstchild;
			firstchild->prev = q;
			firstchild = q;
		}
		else {
			ASSERT(lastchild == NULL);
			firstchild = lastchild = q;
			q->prev = q->next = NULL;
		}
	q->CancelModeDeep();
	if(updaterect)
		q->UpdateRect();
	ChildAdded(q);
	q->ParentChange();
	if(updaterect && GetTopCtrl()->IsOpen())
		q->StateH(OPEN);
	if(dynamic_cast<DHCtrl *>(q))
		SyncDHCtrl();
}

Ctrl::Ctrl() {
	GuiLock __;
	LLOG("Ctrl::Ctrl");
	destroying = false;
	owned = false; // <---This line initialized owned to make
                       // which is necessary!
	parent = prev = next = firstchild = lastchild = NULL;

...
public:
...
     // query owned flag
     bool IsOwned()const{ return owned; }
     Ctrl& Owned(bool b=false){ owned=b; return *this; }

...
};

class App: public TopWindow{
...

App()
{
   Button * p  = new Button();
   Button * p2 = new Button();   

   this->Add(p.Owned());

   this->Add(p2); // Error, p2 is not owned.

   // fixed p2;
   p2.Owned();

};

	bool			IsOwned()const{ return owned; }
	Ctrl&			Owned(bool v=true){ owned=v; return *this; }

Ctrl::Ctrl() {
	GuiLock __;
	LLOG("Ctrl::Ctrl");
	destroying = false;
	owned = false;  // <-----This line is added
	parent = prev = next = firstchild = lastchild = NULL;
	top = NULL;
	exitcode = 0;
	frame.Add().frame = &NullFrame();
	enabled = visible = wantfocus = initfocus = true;
	editable = true;
//	GLX = false;
#ifdef PLATFORM_WIN32
	activex = false;
	isdhctrl = false;
#endif
	backpaint = IsCompositedGui() ? FULLBACKPAINT : TRANSPARENTBACKPAINT;
	inframe = false;
	ignoremouse = transparent = false;
	caretcx = caretcy = caretx = carety = 0;
	SetRect(Rect(0, 0, 0, 0));
	inloop = popup = isopen = false;
	modify = false;
	unicode = false;
	popupgrab = false;
	fullrefresh = false;
	akv = false;
	hasdhctrl = false;
}

// @param: q , the child to be added
//         q,  an existing child to precede p
void  Ctrl::AddChild(Ctrl *q, Ctrl *p)
{
	GuiLock __;
	ASSERT(q);

	LLOG("Add " << UPP::Name(q) << " to: " << Name());
	if(p == q) return;
	bool updaterect = true;
	
	// remember and change
	bool owned=q->owned;
	q->Owned(false); // that way it's guarenteed not to be
				// accidently delete'd when possibly changing parents


	if(q->parent) {
		ASSERT(!q->inframe);
		if(q->parent == this) {
			RemoveChild0(q); 
			updaterect = false;
		}
		else
			q->parent->RemoveChild(q); 
	}
	q->parent = this;
	if(p) {
		ASSERT(p->parent == this);
		q->prev = p;
		q->next = p->next;
		if(p == lastchild)
			lastchild = q;
		else
			p->next->prev = q;
		p->next = q;
	}
	else
		if(firstchild) {
			q->prev = NULL;
			q->next = firstchild;
			firstchild->prev = q;
			firstchild = q;
		}
		else {
			ASSERT(lastchild == NULL);
			firstchild = lastchild = q;
			q->prev = q->next = NULL;
		}
		
	// succesfully added as children of *this, now
	// it's perfect time to restore saved owned flag
	q->Owned(owned);
	
	q->CancelModeDeep();
	if(updaterect)
		q->UpdateRect();
	ChildAdded(q);
	q->ParentChange();
	if(updaterect && GetTopCtrl()->IsOpen())
		q->StateH(OPEN);
	if(dynamic_cast<DHCtrl *>(q))
		SyncDHCtrl();
}

.....

void  Ctrl::RemoveChild0(Ctrl *q)
{
	GuiLock __;
	ChildRemoved(q);
	q->DoRemove();
	q->parent = NULL;
	if(q == firstchild)
		firstchild = firstchild->next;
	if(q == lastchild)
		lastchild = lastchild->prev;
	if(q->prev)
		q->prev->next = q->next;
	if(q->next)
		q->next->prev = q->prev;
	q->next = q->prev = NULL;
	
	if(dynamic_cast<DHCtrl *>(q))
		SyncDHCtrl();
	// code added to allowed owned child****
	if(q->owned)
		delete q;
	// end code added by Lance
}

void  Ctrl::RemoveChild(Ctrl *q)
{
	GuiLock __;
	if(q->parent != this) return;
	q->RefreshFrame();
	
	bool owned=q->IsOwned();
	q->Owned(false); // we still need it to be alive
	
	RemoveChild0(q); 
	q->ParentChange();
	if(GetTopCtrl()->IsOpen())
		q->StateH(CLOSE);

	if( owned )
	{
		delete q; // this is why the new'd-only requirement.	
	}
	// no need to restore q's owned flag, it's either destroyed or 
	// its owned flag is correctly set
}

#include <CtrlLib/CtrlLib.h>

// http://java.sun.com/docs/books/tutorial/uiswing/start/swingTour.html

using namespace Upp;

struct MyButton : Moveable<MyButton>, Button
{
public:
	// should always default to false to confirm with
	// existing U++ users habit
	//
	MyButton(bool toBeOwned=false)
	{
		if(toBeOwned)
			Owned();
	}
	virtual ~MyButton()
	{
		String msg=String().Cat()<<"From within MyButton's destructor, with label "<<GetLabel();
		
		DUMP(msg);	
	}
};

struct ButtonApp : TopWindow {
	int    count;
	MyButton button;
	
	Label  label;

	void RefreshLabel()
	{
		label = Format("Number of button clicks %d", count);
	}
	void Click()
	{
		++count;
		RefreshLabel();
	}

	typedef ButtonApp CLASSNAME;

	ButtonApp()
	{
		count = 0;
		//button=*new MyButton();
		Button * p = new MyButton(true);
		Button * p2 = new MyButton();
		
		button <<= THISBACK(Click);
		button.SetLabel("&I'm an Ultimate++ button!");
		Add(button.VCenterPos(20).HCenterPos(200));
		Add(label.BottomPos(0, 20).HCenterPos(200));
		label.SetAlign(ALIGN_CENTER);
		Sizeable().Zoomable();
		RefreshLabel();

		Add(p->SetLabel("&Another button").TopPosZ(10, 50).LeftPosZ(30, 200)); // becuase MyButton is contructed with proper flag
		Add(p2->SetLabel("Heap Button 2").TopPosZ(10, 50).LeftPosZ(250,200).Owned());
	}
};

GUI_APP_MAIN
{
	ButtonApp().Run();
}

msg = From within MyButton's destructor, with label I'm an Ultimate++ button!
msg = From within MyButton's destructor, with label Another button
msg = From within MyButton's destructor, with label Heap Button 2

struct Parent : ParentCtrl {
   Array<Ctrl> child;

   template<class T> T& Create() { T& x = child.Create<T>(); Add(x); return x; }
};