EditField e;
e.SetFont(Arial(20)).Password().InitCaps();

EditField e;
e.font = Arial(20);
e.password = true;
e.initcaps = true;

a.SetSize(100);
a[99] = 10;

a.At(99) = 10;

int * a = malloc(100);
realloc(a, 200);
*a = 10;

Vector< Vector<int> > a;
a.At(10).At(20) = 10;

a[i++] = a[i];

a[i] = a[i+1];
i++;

a[i] = a.At(j)

Array<int> a(1);
for(int i = 2, i < 1000; i++)
  a.At(i) = i;

Array<int> a(1);
for(int i = 2, i < 1000; i++)
{
  a.CheckSize(i, 1000);
  a[i] = i;
}

a.CheckSize(i);
a[i] = i;

a.CheckSize(x).CheckSize(y);
a[x][y];

a.CheckSize(x).CheckSize(y);
a.At(x).At(y)

a.Dup(0);

a.Grow(1);
a.Last() = a[0]

a.CheckSize(100)[100] = 5;

a.CheckSize(100)[100] = a[10];

a.CheckSize(100);
a[100] = 5;

array<int> a, b;
a.At(1000) = 1;
b = a;
a[10] = 2;  <==ERROR
b[10] = 2;  <==OK

array<int> a, b;
a.At(1000) = 1;
b = a;      <== b and a share same memory area
a[10] = 2;  <== here an automatic deep copy, ok
b[10] = 2;  <== here no deep copy, just array access, ok

array<int> a, b;
a.At(1000) = 1;
b = a;      <== deep copy
a[10] = 2;  <==OK
b[10] = 2;  <==OK

array<int> a;
a = MyFunc(x);

Array<Ctrl> CreateWidgets()
{
    Array<Ctrl> x;
    ...
    return x;
}

Array<Ctrl> CreateWidgets()
{
    Array<Ctrl> x;  <== here, a single reference to memory object
    ...
    return x; <== here, for a while, 2 references to THE SAME memory object
}

ctrls = CreateWidgets() <== here, the first reference is destroyed, leaving a single reference in ctrls

	template<class TT> TT& Create()     { TT *q = new TT; Add(q); return *q; }

Array<Array<Ctrl>> a;
Array<Ctrl> b;
b.Create<Button>();
a.At(10) = b;  // just to be sure that 11-th element exists...

Array<Array<Ctrl>> a; // empty array of arrays of Ctrl
Array<Ctrl> b; // empty array of Ctrl
b.Create<Button>(); // no problem, a button is added to b
a.At(10) = b; // a[10] adds a reference to b object... no problem

b[0] = myCtrl; // don't look for a while at [] problem... 

Array<Array<Ctrl>> ctrls;
ctrls[10].Create<Button>()

Array<Ctrl> a, b;
a.Create<Label>();
a.Create<EditField>();

b = a;

b.Create<Label>(); // Now what?!

Array<Ctrl> a, b;  // two empty arrays, reference to nothing
a.Create<Label>(); // adds a Label to a, a becomes an array with a single reference at underlying data
a.Create<EditField>(); // adds an EditField to a, a is grown by 1 element, as it had a single reference to data, nothing strange happens.
b = a; // now a AND b have both reference to the same underlying array
b.Create<Label>(); // underlying data is copied ....

Array<Ctrl> a;
a.Create<Label>();
a.Create<EditField>();

Array<Ctrl>&b = a;

b.Create<Label>();

Array<Ctrl> MyFunc()
{
  Array<Ctrl> a;
  a.Create<Label>();
  a.Create<EditField>();

  Array<Ctrl>&b = a;

  b.Create<Label>();

  return b;
}

Array<Ctrl> c = MyFunc();

a.At(10) = aString;

a.Add(aControl);

OpenGLExample aControl;
a.Add(aControl);

a.Create<OpenGLExample>();

	int zzz;
	MyAppWindow *win, *win2;
	win = new MyAppWindow;
	win2 = new MyAppWindow;
	OpenGLExample gl, gl2;
	gl.SetFrame(InsetFrame());
	gl2.SetFrame(InsetFrame());
	win->Add(gl.HSizePos(10, 10).VSizePos(10, 10));
	win2->Add(gl2.HSizePos(10, 10).VSizePos(10, 10));
	win->Sizeable().Zoomable();
	win2->Sizeable().Zoomable();

	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 0
	win->OpenMain();
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 1
	win2->OpenMain();
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 2
	delete win;
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 2 !!!
	delete win2;
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 2 !!!
    Ctrl::EventLoop();

	win->Add(gl.HSizePos(10, 10).VSizePos(10, 10));
	win2->Add(gl2.HSizePos(10, 10).VSizePos(10, 10));

	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 0
	win->OpenMain();
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 1
	win2->OpenMain();
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 2
	delete win;
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 1
	delete win2;
	zzz = Ctrl::GetTopCtrls().GetCount(); // zzz = 0

aControl a;  // control is created
aControl b = a; // just reference to inner pimpl object is copied

Vector<Ctrl>*a, *b;
Ctrl c; // control is created, RefCount == 1
a = new Vector<Ctrl>;
b = new Vector<Ctrl>;
a->Add(c); // a gets a *copy* of c, but in reality it adds just to refcount of c, that becomes 2
b->Add(c); // b gets a *copy* of c, but in reality it adds just to refcount of c, that becomes 3
delete a; // a gets destroyed, RefCount in c becomes 2