X-Git-Url: http://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fgx%2Fgh_ui.pas;h=4f4133f84d38bcf13ae95ea22a2f367f0f55ce29;hb=007b3a8fcfe260417aa379da9e6b4e84ddc028d4;hp=aa94e62f463e57e405215ee6d7d938e506a4b725;hpb=73dcd471279fb6cc58e944fb56ad863955eb742e;p=d2df-sdl.git

diff --git a/src/gx/gh_ui.pas b/src/gx/gh_ui.pas
index aa94e62..4f4133f 100644
--- a/src/gx/gh_ui.pas
+++ b/src/gx/gh_ui.pas
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *)
 {$INCLUDE ../shared/a_modes.inc}
+{$M+}
 unit gh_ui;
 
 interface
@@ -21,17 +22,22 @@ interface
 uses
   SysUtils, Classes,
   GL, GLExt, SDL2,
-  sdlcarcass, glgfx;
+  gh_ui_common,
+  sdlcarcass, glgfx,
+  xparser;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
 type
+  THControlClass = class of THControl;
+
   THControl = class
   public
     type TActionCB = procedure (me: THControl; uinfo: Integer);
 
   private
     mParent: THControl;
+    mId: AnsiString;
     mX, mY: Integer;
     mWidth, mHeight: Integer;
     mFrameWidth, mFrameHeight: Integer;
@@ -67,26 +73,102 @@ type
     procedure blurred (); virtual;
 
     //WARNING! do not call scissor functions outside `.draw*()` API!
-    // reset scissor to whole control
-    procedure resetScissor ();
-    // set scissor to this internal rect (in local coords)
+    // set scissor to this rect (in local coords)
     procedure setScissor (lx, ly, lw, lh: Integer);
+    // reset scissor to whole control
+    procedure resetScissor (fullArea: Boolean); inline; // "full area" means "with frame"
 
     // DO NOT USE!
+    // set scissor to this rect (in global coords)
     procedure setScissorGLInternal (x, y, w, h: Integer);
 
   public
     actionCB: TActionCB;
 
+  private
+    mDefSize: TLaySize; // default size
+    mMaxSize: TLaySize; // maximum size
+    mFlex: Integer;
+    mHoriz: Boolean;
+    mCanWrap: Boolean;
+    mLineStart: Boolean;
+    mHGroup: AnsiString;
+    mVGroup: AnsiString;
+    mAlign: Integer;
+    mExpand: Boolean;
+    mLayDefSize: TLaySize;
+    mLayMaxSize: TLaySize;
+
+  public
+    // layouter interface
+    function getDefSize (): TLaySize; inline; // default size; <0: use max size
+    //procedure setDefSize (const sz: TLaySize); inline; // default size; <0: use max size
+    function getMargins (): TLayMargins; inline;
+    function getMaxSize (): TLaySize; inline; // max size; <0: set to some huge value
+    //procedure setMaxSize (const sz: TLaySize); inline; // max size; <0: set to some huge value
+    function getFlex (): Integer; inline; // <=0: not flexible
+    function isHorizBox (): Boolean; inline; // horizontal layout for children?
+    procedure setHorizBox (v: Boolean); inline; // horizontal layout for children?
+    function canWrap (): Boolean; inline; // for horizontal boxes: can wrap children? for child: `false` means 'nonbreakable at *next* ctl'
+    procedure setCanWrap (v: Boolean); inline; // for horizontal boxes: can wrap children? for child: `false` means 'nonbreakable at *next* ctl'
+    function isLineStart (): Boolean; inline; // `true` if this ctl should start a new line; ignored for vertical boxes
+    procedure setLineStart (v: Boolean); inline; // `true` if this ctl should start a new line; ignored for vertical boxes
+    function getAlign (): Integer; inline; // aligning in non-main direction: <0: left/up; 0: center; >0: right/down
+    procedure setAlign (v: Integer); inline; // aligning in non-main direction: <0: left/up; 0: center; >0: right/down
+    function getExpand (): Boolean; inline; // expanding in non-main direction: `true` will ignore align and eat all available space
+    procedure setExpand (v: Boolean); inline; // expanding in non-main direction: `true` will ignore align and eat all available space
+    function getHGroup (): AnsiString; inline; // empty: not grouped
+    procedure setHGroup (const v: AnsiString); inline; // empty: not grouped
+    function getVGroup (): AnsiString; inline; // empty: not grouped
+    procedure setVGroup (const v: AnsiString); inline; // empty: not grouped
+
+    procedure setActualSizePos (constref apos: TLayPos; constref asize: TLaySize); inline;
+
+    procedure layPrepare (); virtual; // called before registering control in layouter
+
+  public
+    property flex: Integer read mFlex write mFlex;
+    property flDefaultSize: TLaySize read mDefSize write mDefSize;
+    property flMaxSize: TLaySize read mMaxSize write mMaxSize;
+    property flHoriz: Boolean read isHorizBox write setHorizBox;
+    property flCanWrap: Boolean read canWrap write setCanWrap;
+    property flLineStart: Boolean read isLineStart write setLineStart;
+    property flAlign: Integer read getAlign write setAlign;
+    property flExpand: Boolean read getExpand write setExpand;
+    property flHGroup: AnsiString read getHGroup write setHGroup;
+    property flVGroup: AnsiString read getVGroup write setVGroup;
+
+  protected
+    function parsePos (par: TTextParser): TLayPos;
+    function parseSize (par: TTextParser): TLaySize;
+    function parseBool (par: TTextParser): Boolean;
+    function parseAnyAlign (par: TTextParser): Integer;
+    function parseHAlign (par: TTextParser): Integer;
+    function parseVAlign (par: TTextParser): Integer;
+    procedure parseTextAlign (par: TTextParser; var h, v: Integer);
+    procedure parseChildren (par: TTextParser); // par should be on '{'; final '}' is eaten
+
   public
-    constructor Create (ax, ay, aw, ah: Integer; aparent: THControl=nil);
+    // par is on property data
+    // there may be more data in text stream, don't eat it!
+    // return `true` if property name is valid and value was parsed
+    // return `false` if property name is invalid; don't advance parser in this case
+    // throw on property data errors
+    function parseProperty (const prname: AnsiString; par: TTextParser): Boolean; virtual;
+
+    // par should be on '{'; final '}' is eaten
+    procedure parseProperties (par: TTextParser);
+
+  public
+    constructor Create ();
+    constructor Create (ax, ay, aw, ah: Integer);
     destructor Destroy (); override;
 
     // `sx` and `sy` are screen coordinates
-    procedure drawControl (sx, sy: Integer); virtual;
+    procedure drawControl (gx, gy: Integer); virtual;
 
     // called after all children drawn
-    procedure drawControlPost (sx, sy: Integer); virtual;
+    procedure drawControlPost (gx, gy: Integer); virtual;
 
     procedure draw (); virtual;
 
@@ -94,7 +176,9 @@ type
 
     // returns `true` if global coords are inside this control
     function toLocal (var x, y: Integer): Boolean;
+    function toLocal (gx, gy: Integer; out x, y: Integer): Boolean; inline;
     procedure toGlobal (var x, y: Integer);
+    procedure toGlobal (lx, ly: Integer; out x, y: Integer); inline;
 
     // x and y are global coords
     function controlAtXY (x, y: Integer): THControl;
@@ -110,6 +194,7 @@ type
     procedure appendChild (ctl: THControl); virtual;
 
   public
+    property id: AnsiString read mId;
     property x0: Integer read mX;
     property y0: Integer read mY;
     property height: Integer read mHeight;
@@ -129,6 +214,7 @@ type
     mDragStartX, mDragStartY: Integer;
     mWaitingClose: Boolean;
     mInClose: Boolean;
+    mFreeOnClose: Boolean; // default: false
 
   protected
     procedure blurred (); override;
@@ -139,14 +225,19 @@ type
   public
     constructor Create (const atitle: AnsiString; ax, ay: Integer; aw: Integer=-1; ah: Integer=-1);
 
+    function parseProperty (const prname: AnsiString; par: TTextParser): Boolean; override;
+
     procedure centerInScreen ();
 
     // `sx` and `sy` are screen coordinates
-    procedure drawControl (sx, sy: Integer); override;
-    procedure drawControlPost (sx, sy: Integer); override;
+    procedure drawControl (gx, gy: Integer); override;
+    procedure drawControlPost (gx, gy: Integer); override;
 
     function keyEvent (var ev: THKeyEvent): Boolean; override; // returns `true` if event was eaten
     function mouseEvent (var ev: THMouseEvent): Boolean; override; // returns `true` if event was eaten
+
+  public
+    property freeOnClose: Boolean read mFreeOnClose write mFreeOnClose;
   end;
 
 
@@ -163,12 +254,12 @@ type
     mItems: array of TItem;
 
   public
-    constructor Create (ax, ay: Integer; aparent: THControl=nil);
+    constructor Create (ax, ay: Integer);
     destructor Destroy (); override;
 
     procedure appendItem (const atext: AnsiString; acentered: Boolean=false; ahline: Boolean=false);
 
-    procedure drawControl (sx, sy: Integer); override;
+    procedure drawControl (gx, gy: Integer); override;
 
     function mouseEvent (var ev: THMouseEvent): Boolean; override;
     function keyEvent (var ev: THKeyEvent): Boolean; override;
@@ -189,33 +280,176 @@ type
     mCurIndex: Integer;
 
   public
-    constructor Create (ax, ay: Integer; aparent: THControl=nil);
+    constructor Create (ax, ay: Integer);
     destructor Destroy (); override;
 
     procedure appendItem (const atext: AnsiString; bv: PBoolean; aaction: TActionCB=nil);
 
-    procedure drawControl (sx, sy: Integer); override;
+    procedure drawControl (gx, gy: Integer); override;
+
+    function mouseEvent (var ev: THMouseEvent): Boolean; override;
+    function keyEvent (var ev: THKeyEvent): Boolean; override;
+  end;
+
+  // ////////////////////////////////////////////////////////////////////// //
+  THCtlBox = class(THControl)
+  private
+    mHasFrame: Boolean;
+    mCaption: AnsiString;
+
+  public
+    constructor Create (ahoriz: Boolean);
+
+    function parseProperty (const prname: AnsiString; par: TTextParser): Boolean; override;
+
+    procedure drawControl (gx, gy: Integer); override;
+
+    function mouseEvent (var ev: THMouseEvent): Boolean; override;
+    function keyEvent (var ev: THKeyEvent): Boolean; override;
+  end;
+
+  THCtlHBox = class(THCtlBox)
+  public
+    procedure AfterConstruction (); override; // so it will be correctly initialized when created from parser
+  end;
+
+  THCtlVBox = class(THCtlBox)
+  public
+    procedure AfterConstruction (); override; // so it will be correctly initialized when created from parser
+  end;
+
+  // ////////////////////////////////////////////////////////////////////// //
+  THCtlSpan = class(THControl)
+  public
+    constructor Create ();
+
+    procedure AfterConstruction (); override; // so it will be correctly initialized when created from parser
+
+    function parseProperty (const prname: AnsiString; par: TTextParser): Boolean; override;
+
+    procedure drawControl (gx, gy: Integer); override;
+  end;
+
+  // ////////////////////////////////////////////////////////////////////// //
+  THCtlTextLabel = class(THControl)
+  private
+    mText: AnsiString;
+    mHAlign: Integer; // -1: left; 0: center; 1: right; default: left
+    mVAlign: Integer; // -1: top; 0: center; 1: bottom; default: center
+
+  public
+    constructor Create (const atext: AnsiString);
+    //destructor Destroy (); override;
+
+    function parseProperty (const prname: AnsiString; par: TTextParser): Boolean; override;
+
+    procedure drawControl (gx, gy: Integer); override;
 
     function mouseEvent (var ev: THMouseEvent): Boolean; override;
     function keyEvent (var ev: THKeyEvent): Boolean; override;
   end;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
 function uiMouseEvent (ev: THMouseEvent): Boolean;
 function uiKeyEvent (ev: THKeyEvent): Boolean;
 procedure uiDraw ();
 
+
+// ////////////////////////////////////////////////////////////////////////// //
 procedure uiAddWindow (ctl: THControl);
-procedure uiRemoveWindow (ctl: THControl);
+procedure uiRemoveWindow (ctl: THControl); // will free window if `mFreeOnClose` is `true`
 function uiVisibleWindow (ctl: THControl): Boolean;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
+// do layouting
+procedure uiLayoutCtl (ctl: THControl);
+
+
+// ////////////////////////////////////////////////////////////////////////// //
 var
   gh_ui_scale: Single = 1.0;
 
 
 implementation
 
+uses
+  gh_flexlay,
+  utils;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+var
+  knownCtlClasses: array of record
+    klass: THControlClass;
+    name: AnsiString;
+  end = nil;
+
+
+procedure registerCtlClass (aklass: THControlClass; const aname: AnsiString);
+begin
+  assert(aklass <> nil);
+  assert(Length(aname) > 0);
+  SetLength(knownCtlClasses, Length(knownCtlClasses)+1);
+  knownCtlClasses[High(knownCtlClasses)].klass := aklass;
+  knownCtlClasses[High(knownCtlClasses)].name := aname;
+end;
+
+
+function findCtlClass (const aname: AnsiString): THControlClass;
+var
+  f: Integer;
+begin
+  for f := 0 to High(knownCtlClasses) do
+  begin
+    if (strEquCI1251(aname, knownCtlClasses[f].name)) then
+    begin
+      result := knownCtlClasses[f].klass;
+      exit;
+    end;
+  end;
+  result := nil;
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+type
+  TFlexLayouter = specialize TFlexLayouterBase<THControl>;
+
+procedure uiLayoutCtl (ctl: THControl);
+var
+  lay: TFlexLayouter;
+begin
+  if (ctl = nil) then exit;
+  lay := TFlexLayouter.Create();
+  try
+    lay.setup(ctl);
+    //lay.layout();
+
+    //writeln('============================'); lay.dumpFlat();
+
+    //writeln('=== initial ==='); lay.dump();
+
+    //lay.calcMaxSizeInternal(0);
+    {
+    lay.firstPass();
+    writeln('=== after first pass ===');
+    lay.dump();
+
+    lay.secondPass();
+    writeln('=== after second pass ===');
+    lay.dump();
+    }
+
+    lay.layout();
+    //writeln('=== final ==='); lay.dump();
+
+  finally
+    FreeAndNil(lay);
+  end;
+end;
+
 
 // ////////////////////////////////////////////////////////////////////////// //
 var
@@ -237,9 +471,7 @@ begin
   begin
     for f := High(uiTopList) downto 0 do
     begin
-      lx := ev.x;
-      ly := ev.y;
-      if uiTopList[f].toLocal(lx, ly) then
+      if uiTopList[f].toLocal(ev.x, ev.y, lx, ly) then
       begin
         result := true;
         if uiTopList[f].mEnabled and (f <> High(uiTopList)) then
@@ -297,6 +529,7 @@ var
 begin
   if (ctl = nil) then exit;
   ctl := ctl.topLevel;
+  if not (ctl is THTopWindow) then exit; // alas
   for f := 0 to High(uiTopList) do
   begin
     if (uiTopList[f] = ctl) then
@@ -318,13 +551,13 @@ begin
 end;
 
 
-// won't free object
 procedure uiRemoveWindow (ctl: THControl);
 var
   f, c: Integer;
 begin
   if (ctl = nil) then exit;
   ctl := ctl.topLevel;
+  if not (ctl is THTopWindow) then exit; // alas
   for f := 0 to High(uiTopList) do
   begin
     if (uiTopList[f] = ctl) then
@@ -334,7 +567,11 @@ begin
       SetLength(uiTopList, Length(uiTopList)-1);
       if (ctl is THTopWindow) then
       begin
-        if assigned(THTopWindow(ctl).closeCB) then THTopWindow(ctl).closeCB(ctl, 0);
+        try
+          if assigned(THTopWindow(ctl).closeCB) then THTopWindow(ctl).closeCB(ctl, 0);
+        finally
+          if (THTopWindow(ctl).mFreeOnClose) then FreeAndNil(ctl);
+        end;
       end;
       exit;
     end;
@@ -349,6 +586,7 @@ begin
   result := false;
   if (ctl = nil) then exit;
   ctl := ctl.topLevel;
+  if not (ctl is THTopWindow) then exit; // alas
   for f := 0 to High(uiTopList) do
   begin
     if (uiTopList[f] = ctl) then begin result := true; exit; end;
@@ -357,13 +595,13 @@ end;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
-constructor THControl.Create (ax, ay, aw, ah: Integer; aparent: THControl=nil);
+constructor THControl.Create ();
 begin
-  mParent := aparent;
-  mX := ax;
-  mY := ay;
-  mWidth := aw;
-  mHeight := ah;
+  mParent := nil;
+  mX := 0;
+  mY := 0;
+  mWidth := 64;
+  mHeight := 8;
   mFrameWidth := 0;
   mFrameHeight := 0;
   mEnabled := true;
@@ -376,6 +614,28 @@ begin
   scallowed := false;
   mDrawShadow := false;
   actionCB := nil;
+  // layouter interface
+  //mDefSize := TLaySize.Create(64, 8); // default size
+  mDefSize := TLaySize.Create(0, 0); // default size
+  mMaxSize := TLaySize.Create(-1, -1); // maximum size
+  mFlex := 0;
+  mHoriz := true;
+  mCanWrap := false;
+  mLineStart := false;
+  mHGroup := '';
+  mVGroup := '';
+  mAlign := -1; // left/top
+  mExpand := false;
+end;
+
+
+constructor THControl.Create (ax, ay, aw, ah: Integer);
+begin
+  Create();
+  mX := ax;
+  mY := ay;
+  mWidth := aw;
+  mHeight := ah;
 end;
 
 
@@ -404,6 +664,255 @@ begin
 end;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
+function THControl.getDefSize (): TLaySize; inline; begin result := mLayDefSize; end;
+function THControl.getMaxSize (): TLaySize; inline; begin result := mLayMaxSize; end;
+function THControl.getFlex (): Integer; inline; begin result := mFlex; end;
+function THControl.isHorizBox (): Boolean; inline; begin result := mHoriz; end;
+procedure THControl.setHorizBox (v: Boolean); inline; begin mHoriz := v; end;
+function THControl.canWrap (): Boolean; inline; begin result := mCanWrap; end;
+procedure THControl.setCanWrap (v: Boolean); inline; begin mCanWrap := v; end;
+function THControl.isLineStart (): Boolean; inline; begin result := mLineStart; end;
+procedure THControl.setLineStart (v: Boolean); inline; begin mLineStart := v; end;
+function THControl.getAlign (): Integer; inline; begin result := mAlign; end;
+procedure THControl.setAlign (v: Integer); inline; begin mAlign := v; end;
+function THControl.getExpand (): Boolean; inline; begin result := mExpand; end;
+procedure THControl.setExpand (v: Boolean); inline; begin mExpand := v; end;
+function THControl.getHGroup (): AnsiString; inline; begin result := mHGroup; end;
+procedure THControl.setHGroup (const v: AnsiString); inline; begin mHGroup := v; end;
+function THControl.getVGroup (): AnsiString; inline; begin result := mVGroup; end;
+procedure THControl.setVGroup (const v: AnsiString); inline; begin mVGroup := v; end;
+
+function THControl.getMargins (): TLayMargins; inline;
+begin
+  result := TLayMargins.Create(mFrameHeight, mFrameWidth, mFrameHeight, mFrameWidth);
+end;
+
+procedure THControl.setActualSizePos (constref apos: TLayPos; constref asize: TLaySize); inline; begin
+  //writeln(self.className, '; pos=', apos.toString, '; size=', asize.toString);
+  if (mParent <> nil) then
+  begin
+    mX := apos.x;
+    mY := apos.y;
+  end;
+  mWidth := asize.w;
+  mHeight := asize.h;
+end;
+
+procedure THControl.layPrepare ();
+begin
+  mLayDefSize := mDefSize;
+  mLayMaxSize := mMaxSize;
+  if (mLayMaxSize.w >= 0) then mLayMaxSize.w += mFrameWidth*2;
+  if (mLayMaxSize.h >= 0) then mLayMaxSize.h += mFrameHeight*2;
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+function THControl.parsePos (par: TTextParser): TLayPos;
+var
+  ech: AnsiChar = ')';
+begin
+  if (par.eatDelim('[')) then ech := ']' else par.expectDelim('(');
+  result.x := par.expectInt();
+  par.eatDelim(','); // optional comma
+  result.y := par.expectInt();
+  par.eatDelim(','); // optional comma
+  par.expectDelim(ech);
+end;
+
+function THControl.parseSize (par: TTextParser): TLaySize;
+var
+  ech: AnsiChar = ')';
+begin
+  if (par.eatDelim('[')) then ech := ']' else par.expectDelim('(');
+  result.w := par.expectInt();
+  par.eatDelim(','); // optional comma
+  result.h := par.expectInt();
+  par.eatDelim(','); // optional comma
+  par.expectDelim(ech);
+end;
+
+function THControl.parseBool (par: TTextParser): Boolean;
+begin
+  result :=
+    par.eatIdOrStr('true', false) or
+    par.eatIdOrStr('yes', false) or
+    par.eatIdOrStr('tan', false);
+  if not result then
+  begin
+    if (not par.eatIdOrStr('false', false)) and (not par.eatIdOrStr('no', false)) and (not par.eatIdOrStr('ona', false)) then
+    begin
+      par.error('boolean value expected');
+    end;
+  end;
+end;
+
+function THControl.parseAnyAlign (par: TTextParser): Integer;
+begin
+       if (par.eatIdOrStr('left', false)) or (par.eatIdOrStr('top', false)) then result := -1
+  else if (par.eatIdOrStr('right', false)) or (par.eatIdOrStr('bottom', false)) then result := 1
+  else if (par.eatIdOrStr('center', false)) then result := 0
+  else par.error('invalid align value');
+end;
+
+function THControl.parseHAlign (par: TTextParser): Integer;
+begin
+       if (par.eatIdOrStr('left', false)) then result := -1
+  else if (par.eatIdOrStr('right', false)) then result := 1
+  else if (par.eatIdOrStr('center', false)) then result := 0
+  else par.error('invalid horizontal align value');
+end;
+
+function THControl.parseVAlign (par: TTextParser): Integer;
+begin
+       if (par.eatIdOrStr('top', false)) then result := -1
+  else if (par.eatIdOrStr('bottom', false)) then result := 1
+  else if (par.eatIdOrStr('center', false)) then result := 0
+  else par.error('invalid vertical align value');
+end;
+
+procedure THControl.parseTextAlign (par: TTextParser; var h, v: Integer);
+var
+  wasH: Boolean = false;
+  wasV: Boolean = false;
+begin
+  while true do
+  begin
+    if (par.eatIdOrStr('left', false)) then
+    begin
+      if wasH then par.error('too many align directives');
+      wasH := true;
+      h := -1;
+      continue;
+    end;
+    if (par.eatIdOrStr('right', false)) then
+    begin
+      if wasH then par.error('too many align directives');
+      wasH := true;
+      h := 1;
+      continue;
+    end;
+    if (par.eatIdOrStr('hcenter', false)) then
+    begin
+      if wasH then par.error('too many align directives');
+      wasH := true;
+      h := 0;
+      continue;
+    end;
+    if (par.eatIdOrStr('top', false)) then
+    begin
+      if wasV then par.error('too many align directives');
+      wasV := true;
+      v := -1;
+      continue;
+    end;
+    if (par.eatIdOrStr('bottom', false)) then
+    begin
+      if wasV then par.error('too many align directives');
+      wasV := true;
+      v := 1;
+      continue;
+    end;
+    if (par.eatIdOrStr('vcenter', false)) then
+    begin
+      if wasV then par.error('too many align directives');
+      wasV := true;
+      v := 0;
+      continue;
+    end;
+    if (par.eatIdOrStr('center', false)) then
+    begin
+      if wasV or wasH then par.error('too many align directives');
+      wasV := true;
+      wasH := true;
+      h := 0;
+      v := 0;
+      continue;
+    end;
+    break;
+  end;
+  if not wasV and not wasH then par.error('invalid align value');
+end;
+
+// par should be on '{'; final '}' is eaten
+procedure THControl.parseProperties (par: TTextParser);
+var
+  pn: AnsiString;
+begin
+  if (not par.eatDelim('{')) then exit;
+  while (not par.eatDelim('}')) do
+  begin
+    if (not par.isIdOrStr) then par.error('property name expected');
+    pn := par.tokStr;
+    par.skipToken();
+    par.eatDelim(':'); // optional
+    if not parseProperty(pn, par) then par.errorfmt('invalid property name ''%s''', [pn]);
+    par.eatDelim(','); // optional
+  end;
+end;
+
+// par should be on '{'
+procedure THControl.parseChildren (par: TTextParser);
+var
+  cc: THControlClass;
+  ctl: THControl;
+begin
+  par.expectDelim('{');
+  while (not par.eatDelim('}')) do
+  begin
+    if (not par.isIdOrStr) then par.error('control name expected');
+    cc := findCtlClass(par.tokStr);
+    if (cc = nil) then par.errorfmt('unknown control name: ''%s''', [par.tokStr]);
+    //writeln('children for <', par.tokStr, '>: <', cc.className, '>');
+    par.skipToken();
+    par.eatDelim(':'); // optional
+    ctl := cc.Create();
+    //writeln('  mHoriz=', ctl.mHoriz);
+    try
+      ctl.parseProperties(par);
+    except
+      FreeAndNil(ctl);
+      raise;
+    end;
+    //writeln(': ', ctl.mDefSize.toString);
+    appendChild(ctl);
+    par.eatDelim(','); // optional
+  end;
+end;
+
+
+function THControl.parseProperty (const prname: AnsiString; par: TTextParser): Boolean;
+begin
+  result := true;
+  if (strEquCI1251(prname, 'id')) then begin mId := par.expectStrOrId(true); exit; end; // allow empty strings
+  if (strEquCI1251(prname, 'flex')) then begin flex := par.expectInt(); exit; end;
+  // sizes
+  if (strEquCI1251(prname, 'defsize')) or (strEquCI1251(prname, 'size')) then begin mDefSize := parseSize(par); exit; end;
+  if (strEquCI1251(prname, 'maxsize')) then begin mMaxSize := parseSize(par); exit; end;
+  if (strEquCI1251(prname, 'defwidth')) or (strEquCI1251(prname, 'width')) then begin mDefSize.w := par.expectInt(); exit; end;
+  if (strEquCI1251(prname, 'defheight')) or (strEquCI1251(prname, 'height')) then begin mDefSize.h := par.expectInt(); exit; end;
+  if (strEquCI1251(prname, 'maxwidth')) then begin mMaxSize.w := par.expectInt(); exit; end;
+  if (strEquCI1251(prname, 'maxheight')) then begin mMaxSize.h := par.expectInt(); exit; end;
+  // flags
+  if (strEquCI1251(prname, 'wrap')) then begin mCanWrap := parseBool(par); exit; end;
+  if (strEquCI1251(prname, 'linestart')) then begin mLineStart := parseBool(par); exit; end;
+  if (strEquCI1251(prname, 'expand')) then begin mExpand := parseBool(par); exit; end;
+  // align
+  if (strEquCI1251(prname, 'align')) then begin mAlign := parseAnyAlign(par); exit; end;
+  if (strEquCI1251(prname, 'hgroup')) then begin mHGroup := par.expectStrOrId(true); exit; end; // allow empty strings
+  if (strEquCI1251(prname, 'vgroup')) then begin mVGroup := par.expectStrOrId(true); exit; end; // allow empty strings
+  // other
+  if (strEquCI1251(prname, 'canfocus')) then begin mCanFocus := parseBool(par); exit; end;
+  if (strEquCI1251(prname, 'enabled')) then begin mEnabled := parseBool(par); exit; end;
+  if (strEquCI1251(prname, 'disabled')) then begin mEnabled := not parseBool(par); exit; end;
+  if (strEquCI1251(prname, 'escclose')) then begin mEscClose := not parseBool(par); exit; end;
+  if (strEquCI1251(prname, 'eatkeys')) then begin mEatKeys := not parseBool(par); exit; end;
+  result := false;
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
 procedure THControl.activated ();
 begin
 end;
@@ -505,6 +1014,12 @@ begin
   result := (x >= 0) and (y >= 0) and (x < mWidth) and (y < mHeight);
 end;
 
+function THControl.toLocal (gx, gy: Integer; out x, y: Integer): Boolean; inline;
+begin
+  x := gx;
+  y := gy;
+  result := toLocal(x, y);
+end;
 
 procedure THControl.toGlobal (var x, y: Integer);
 var
@@ -519,6 +1034,13 @@ begin
   end;
 end;
 
+procedure THControl.toGlobal (lx, ly: Integer; out x, y: Integer); inline;
+begin
+  x := lx;
+  y := ly;
+  toGlobal(x, y);
+end;
+
 
 // x and y are global coords
 function THControl.controlAtXY (x, y: Integer): THControl;
@@ -528,9 +1050,7 @@ var
 begin
   result := nil;
   if (not mEnabled) or (mWidth < 1) or (mHeight < 1) then exit;
-  lx := x;
-  ly := y;
-  if not toLocal(lx, ly) then exit;
+  if not toLocal(x, y, lx, ly) then exit;
   for f := High(mChildren) downto 0 do
   begin
     result := mChildren[f].controlAtXY(x, y);
@@ -675,6 +1195,7 @@ begin
 end;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
 procedure THControl.setScissorGLInternal (x, y, w, h: Integer);
 begin
   if not scallowed then exit;
@@ -682,81 +1203,83 @@ begin
   y := trunc(y*gh_ui_scale);
   w := trunc(w*gh_ui_scale);
   h := trunc(h*gh_ui_scale);
-  //y := gWinSizeY-(y+h);
-  scis.setRect(x, y, w, h);
+  scis.combineRect(x, y, w, h);
 end;
 
-
-procedure THControl.resetScissor ();
+procedure THControl.setScissor (lx, ly, lw, lh: Integer);
 var
-  x, y: Integer;
+  gx, gy: Integer;
+  //ox, oy, ow, oh: Integer;
 begin
   if not scallowed then exit;
-  x := 0;
-  y := 0;
-  toGlobal(x, y);
-  setScissorGLInternal(x, y, mWidth, mHeight);
+  //ox := lx; oy := ly; ow := lw; oh := lh;
+  if not intersectRect(lx, ly, lw, lh, 0, 0, mWidth, mHeight) then
+  begin
+    //writeln('oops: <', self.className, '>: old=(', ox, ',', oy, ')-[', ow, ',', oh, ']');
+    glScissor(0, 0, 0, 0);
+    exit;
+  end;
+  toGlobal(lx, ly, gx, gy);
+  setScissorGLInternal(gx, gy, lw, lh);
 end;
 
-
-procedure THControl.setScissor (lx, ly, lw, lh: Integer);
-var
-  x, y: Integer;
+procedure THControl.resetScissor (fullArea: Boolean); inline;
 begin
   if not scallowed then exit;
-  if not intersectRect(lx, ly, lw, lh, 0, 0, mWidth, mHeight) then begin glScissor(0, 0, 0, 0); exit; end;
-  x := lx;
-  y := ly;
-  toGlobal(x, y);
-  setScissorGLInternal(x, y, lw, lh);
+  if (fullArea) then
+  begin
+    setScissor(0, 0, mWidth, mHeight);
+  end
+  else
+  begin
+    setScissor(mFrameWidth, mFrameHeight, mWidth-mFrameWidth*2, mHeight-mFrameHeight*2);
+  end;
 end;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
 procedure THControl.draw ();
 var
   f: Integer;
-  x, y: Integer;
+  gx, gy: Integer;
 begin
   if (mWidth < 1) or (mHeight < 1) then exit;
-  x := 0;
-  y := 0;
-  toGlobal(x, y);
+  toGlobal(0, 0, gx, gy);
   //conwritefln('[%s]: (%d,%d)-(%d,%d)  (%d,%d)', [ClassName, mX, mY, mWidth, mHeight, x, y]);
 
   scis.save(true); // scissoring enabled
   try
-    //glEnable(GL_SCISSOR_TEST);
     scallowed := true;
-    resetScissor();
-    drawControl(x, y);
-    if (mFrameWidth <> 0) or (mFrameHeight <> 0) then setScissor(mFrameWidth, mFrameHeight, mWidth-mFrameWidth*2, mHeight-mFrameHeight*2);
+    resetScissor(true); // full area
+    drawControl(gx, gy);
+    resetScissor(false); // client area
     for f := 0 to High(mChildren) do mChildren[f].draw();
-    if (mFrameWidth <> 0) or (mFrameHeight <> 0) then resetScissor();
-    drawControlPost(x, y);
+    resetScissor(true); // full area
+    drawControlPost(gx, gy);
   finally
     scis.restore();
     scallowed := false;
   end;
 end;
 
-
-procedure THControl.drawControl (sx, sy: Integer);
+procedure THControl.drawControl (gx, gy: Integer);
 begin
-  if (mParent = nil) then darkenRect(sx, sy, mWidth, mHeight, 64);
+  if (mParent = nil) then darkenRect(gx, gy, mWidth, mHeight, 64);
 end;
 
-
-procedure THControl.drawControlPost (sx, sy: Integer);
+procedure THControl.drawControlPost (gx, gy: Integer);
 begin
+  // shadow
   if mDrawShadow and (mWidth > 0) and (mHeight > 0) then
   begin
-    setScissorGLInternal(sx+8, sy+8, mWidth, mHeight);
-    darkenRect(sx+mWidth, sy+8, 8, mHeight, 128);
-    darkenRect(sx+8, sy+mHeight, mWidth-8, 8, 128);
+    setScissorGLInternal(gx+8, gy+8, mWidth, mHeight);
+    darkenRect(gx+mWidth, gy+8, 8, mHeight, 128);
+    darkenRect(gx+8, gy+mHeight, mWidth-8, 8, 128);
   end;
 end;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
 function THControl.mouseEvent (var ev: THMouseEvent): Boolean;
 var
   ctl: THControl;
@@ -831,7 +1354,7 @@ end;
 // ////////////////////////////////////////////////////////////////////////// //
 constructor THTopWindow.Create (const atitle: AnsiString; ax, ay: Integer; aw: Integer=-1; ah: Integer=-1);
 begin
-  inherited Create(ax, ay, aw, ah, nil);
+  inherited Create(ax, ay, aw, ah);
   mFrameWidth := 8;
   mFrameHeight := 8;
   mTitle := atitle;
@@ -849,6 +1372,32 @@ begin
 end;
 
 
+function THTopWindow.parseProperty (const prname: AnsiString; par: TTextParser): Boolean;
+begin
+  if (strEquCI1251(prname, 'title')) or (strEquCI1251(prname, 'caption')) then
+  begin
+    mTitle := par.expectStrOrId(true);
+    result := true;
+    exit;
+  end;
+  if (strEquCI1251(prname, 'children')) then
+  begin
+    parseChildren(par);
+    result := true;
+    exit;
+  end;
+  if (strEquCI1251(prname, 'orientation')) or (strEquCI1251(prname, 'orient')) then
+  begin
+         if (par.eatIdOrStr('horizontal', false)) or (par.eatIdOrStr('horiz', false)) then mHoriz := true
+    else if (par.eatIdOrStr('vertical', false)) or (par.eatIdOrStr('vert', false)) then mHoriz := false
+    else par.error('`horizontal` or `vertical` expected');
+    result := true;
+    exit;
+  end;
+  result := inherited parseProperty(prname, par);
+end;
+
+
 procedure THTopWindow.centerInScreen ();
 begin
   if (mWidth > 0) and (mHeight > 0) then
@@ -859,13 +1408,13 @@ begin
 end;
 
 
-procedure THTopWindow.drawControl (sx, sy: Integer);
+procedure THTopWindow.drawControl (gx, gy: Integer);
 begin
-  fillRect(sx, sy, mWidth, mHeight, 0, 0, 128);
+  fillRect(gx, gy, mWidth, mHeight, 0, 0, 128);
 end;
 
 
-procedure THTopWindow.drawControlPost (sx, sy: Integer);
+procedure THTopWindow.drawControlPost (gx, gy: Integer);
 const r = 255;
 const g = 255;
 const b = 255;
@@ -893,7 +1442,7 @@ begin
     fillRect(tx-3, mY, Length(mTitle)*8+3+2, 8, 0, 0, 128);
     drawText8(tx, mY, mTitle, r, g, b);
   end;
-  inherited drawControlPost(sx, sy);
+  inherited drawControlPost(gx, gy);
 end;
 
 
@@ -938,9 +1487,7 @@ begin
     exit;
   end;
 
-  lx := ev.x;
-  ly := ev.y;
-  if toLocal(lx, ly) then
+  if toLocal(ev.x, ev.y, lx, ly) then
   begin
     if (ev.press) then
     begin
@@ -1004,7 +1551,7 @@ end;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
-constructor THCtlSimpleText.Create (ax, ay: Integer; aparent: THControl=nil);
+constructor THCtlSimpleText.Create (ax, ay: Integer);
 begin
   mItems := nil;
   inherited Create(ax, ay, 4, 4);
@@ -1032,7 +1579,7 @@ begin
 end;
 
 
-procedure THCtlSimpleText.drawControl (sx, sy: Integer);
+procedure THCtlSimpleText.drawControl (gx, gy: Integer);
 var
   f, tx: Integer;
   it: PItem;
@@ -1041,26 +1588,26 @@ begin
   for f := 0 to High(mItems) do
   begin
     it := @mItems[f];
-    tx := sx;
+    tx := gx;
     r := 255;
     g := 255;
     b := 0;
-    if it.centered then begin b := 255; tx := sx+(mWidth-Length(it.title)*8) div 2; end;
+    if it.centered then begin b := 255; tx := gx+(mWidth-Length(it.title)*8) div 2; end;
     if it.hline then
     begin
       b := 255;
       if (Length(it.title) = 0) then
       begin
-        drawHLine(sx+4, sy+3, mWidth-8, r, g, b);
+        drawHLine(gx+4, gy+3, mWidth-8, r, g, b);
       end
-      else if (tx-3 > sx+4) then
+      else if (tx-3 > gx+4) then
       begin
-        drawHLine(sx+4, sy+3, tx-3-(sx+3), r, g, b);
-        drawHLine(tx+Length(it.title)*8, sy+3, mWidth-4, r, g, b);
+        drawHLine(gx+4, gy+3, tx-3-(gx+3), r, g, b);
+        drawHLine(tx+Length(it.title)*8, gy+3, mWidth-4, r, g, b);
       end;
     end;
-    drawText8(tx, sy, it.title, r, g, b);
-    Inc(sy, 8);
+    drawText8(tx, gy, it.title, r, g, b);
+    Inc(gy, 8);
   end;
 end;
 
@@ -1070,9 +1617,7 @@ var
   lx, ly: Integer;
 begin
   result := inherited mouseEvent(ev);
-  lx := ev.x;
-  ly := ev.y;
-  if not result and toLocal(lx, ly) then
+  if not result and toLocal(ev.x, ev.y, lx, ly) then
   begin
     result := true;
   end;
@@ -1086,7 +1631,7 @@ end;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
-constructor THCtlCBListBox.Create (ax, ay: Integer; aparent: THControl=nil);
+constructor THCtlCBListBox.Create (ax, ay: Integer);
 begin
   mItems := nil;
   mCurIndex := -1;
@@ -1116,7 +1661,7 @@ begin
 end;
 
 
-procedure THCtlCBListBox.drawControl (sx, sy: Integer);
+procedure THCtlCBListBox.drawControl (gx, gy: Integer);
 var
   f, tx: Integer;
   it: PItem;
@@ -1124,27 +1669,27 @@ begin
   for f := 0 to High(mItems) do
   begin
     it := @mItems[f];
-    if (mCurIndex = f) then fillRect(sx, sy, mWidth, 8, 0, 128, 0);
+    if (mCurIndex = f) then fillRect(gx, gy, mWidth, 8, 0, 128, 0);
     if (it.varp <> nil) then
     begin
-      if it.varp^ then drawText8(sx, sy, '[x]', 255, 255, 255) else drawText8(sx, sy, '[ ]', 255, 255, 255);
-      drawText8(sx+3*8+2, sy, it.title, 255, 255, 0);
+      if it.varp^ then drawText8(gx, gy, '[x]', 255, 255, 255) else drawText8(gx, gy, '[ ]', 255, 255, 255);
+      drawText8(gx+3*8+2, gy, it.title, 255, 255, 0);
     end
     else if (Length(it.title) > 0) then
     begin
-      tx := sx+(mWidth-Length(it.title)*8) div 2;
-      if (tx-3 > sx+4) then
+      tx := gx+(mWidth-Length(it.title)*8) div 2;
+      if (tx-3 > gx+4) then
       begin
-        drawHLine(sx+4, sy+3, tx-3-(sx+3), 255, 255, 255);
-        drawHLine(tx+Length(it.title)*8, sy+3, mWidth-4, 255, 255, 255);
+        drawHLine(gx+4, gy+3, tx-3-(gx+3), 255, 255, 255);
+        drawHLine(tx+Length(it.title)*8, gy+3, mWidth-4, 255, 255, 255);
       end;
-      drawText8(tx, sy, it.title, 255, 255, 255);
+      drawText8(tx, gy, it.title, 255, 255, 255);
     end
     else
     begin
-      drawHLine(sx+4, sy+3, mWidth-8, 255, 255, 255);
+      drawHLine(gx+4, gy+3, mWidth-8, 255, 255, 255);
     end;
-    Inc(sy, 8);
+    Inc(gy, 8);
   end;
 end;
 
@@ -1155,9 +1700,7 @@ var
   it: PItem;
 begin
   result := inherited mouseEvent(ev);
-  lx := ev.x;
-  ly := ev.y;
-  if not result and toLocal(lx, ly) then
+  if not result and toLocal(ev.x, ev.y, lx, ly) then
   begin
     result := true;
     if (ev = 'lmb') then
@@ -1244,4 +1787,213 @@ begin
 end;
 
 
+// ////////////////////////////////////////////////////////////////////////// //
+constructor THCtlBox.Create (ahoriz: Boolean);
+begin
+  inherited Create();
+  mHoriz := ahoriz;
+end;
+
+
+function THCtlBox.parseProperty (const prname: AnsiString; par: TTextParser): Boolean;
+begin
+  if (strEquCI1251(prname, 'orientation')) or (strEquCI1251(prname, 'orient')) then
+  begin
+         if (par.eatIdOrStr('horizontal', false)) or (par.eatIdOrStr('horiz', false)) then mHoriz := true
+    else if (par.eatIdOrStr('vertical', false)) or (par.eatIdOrStr('vert', false)) then mHoriz := false
+    else par.error('`horizontal` or `vertical` expected');
+    result := true;
+    exit;
+  end;
+  if (strEquCI1251(prname, 'frame')) then
+  begin
+    mHasFrame := parseBool(par);
+    if (mHasFrame) then begin mFrameWidth := 8; mFrameHeight := 8; end else begin mFrameWidth := 0; mFrameHeight := 0; end;
+    result := true;
+    exit;
+  end;
+  if (strEquCI1251(prname, 'title')) or (strEquCI1251(prname, 'caption')) then
+  begin
+    mCaption := par.expectStrOrId(true);
+    mDefSize := TLaySize.Create(Length(mCaption)*8+3, 8);
+    result := true;
+    exit;
+  end;
+  if (strEquCI1251(prname, 'children')) then
+  begin
+    parseChildren(par);
+    result := true;
+    exit;
+  end;
+  result := inherited parseProperty(prname, par);
+end;
+
+
+procedure THCtlBox.drawControl (gx, gy: Integer);
+var
+  r, g, b: Integer;
+  tx: Integer;
+begin
+  if focused then begin r := 255; g := 255; b := 255; end else begin r := 255; g := 255; b := 0; end;
+  if mHasFrame then
+  begin
+    // draw frame
+    drawRectUI(gx+3, gy+3, mWidth-6, mHeight-6, r, g, b);
+  end;
+  // draw caption
+  if (Length(mCaption) > 0) then
+  begin
+    setScissor(mFrameWidth+1, 0, mWidth-mFrameWidth-2, 8);
+    tx := gx+((mWidth-Length(mCaption)*8) div 2);
+    if mHasFrame then fillRect(tx-2, gy, Length(mCaption)*8+3, 8, 0, 0, 128);
+    drawText8(tx, gy, mCaption, r, g, b);
+  end;
+end;
+
+
+function THCtlBox.mouseEvent (var ev: THMouseEvent): Boolean;
+var
+  lx, ly: Integer;
+begin
+  result := inherited mouseEvent(ev);
+  if not result and toLocal(ev.x, ev.y, lx, ly) then
+  begin
+    result := true;
+  end;
+end;
+
+
+//TODO: navigation with arrow keys, according to box orientation
+function THCtlBox.keyEvent (var ev: THKeyEvent): Boolean;
+begin
+  result := inherited keyEvent(ev);
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+procedure THCtlHBox.AfterConstruction ();
+begin
+  inherited AfterConstruction();
+  mHoriz := true;
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+procedure THCtlVBox.AfterConstruction ();
+begin
+  inherited AfterConstruction();
+  mHoriz := false;
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+constructor THCtlSpan.Create ();
+begin
+  inherited Create();
+  mExpand := true;
+end;
+
+function THCtlSpan.parseProperty (const prname: AnsiString; par: TTextParser): Boolean;
+begin
+  if (strEquCI1251(prname, 'orientation')) or (strEquCI1251(prname, 'orient')) then
+  begin
+         if (par.eatIdOrStr('horizontal', false)) or (par.eatIdOrStr('horiz', false)) then mHoriz := true
+    else if (par.eatIdOrStr('vertical', false)) or (par.eatIdOrStr('vert', false)) then mHoriz := false
+    else par.error('`horizontal` or `vertical` expected');
+    result := true;
+    exit;
+  end;
+  result := inherited parseProperty(prname, par);
+end;
+
+procedure THCtlSpan.drawControl (gx, gy: Integer);
+begin
+end;
+
+
+procedure THCtlSpan.AfterConstruction ();
+begin
+  inherited AfterConstruction();
+  //mDefSize := TLaySize.Create(0, 8);
+  mExpand := true;
+end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+constructor THCtlTextLabel.Create (const atext: AnsiString);
+begin
+  inherited Create();
+  mHAlign := -1;
+  mVAlign := 0;
+  mText := atext;
+  mDefSize := TLaySize.Create(Length(atext)*8, 8);
+end;
+
+
+function THCtlTextLabel.parseProperty (const prname: AnsiString; par: TTextParser): Boolean;
+begin
+  if (strEquCI1251(prname, 'title')) or (strEquCI1251(prname, 'caption')) then
+  begin
+    mText := par.expectStrOrId(true);
+    mDefSize := TLaySize.Create(Length(mText)*8, 8);
+    result := true;
+    exit;
+  end;
+  if (strEquCI1251(prname, 'textalign')) then
+  begin
+    parseTextAlign(par, mHAlign, mVAlign);
+    result := true;
+    exit;
+  end;
+  result := inherited parseProperty(prname, par);
+end;
+
+
+procedure THCtlTextLabel.drawControl (gx, gy: Integer);
+var
+  xpos, ypos: Integer;
+begin
+  // debug
+  fillRect(gx, gy, mWidth, mHeight, 96, 96, 0);
+  drawRectUI(gx, gy, mWidth, mHeight, 96, 96, 96);
+
+  if (Length(mText) > 0) then
+  begin
+         if (mHAlign < 0) then xpos := 0
+    else if (mHAlign > 0) then xpos := mWidth-Length(mText)*8
+    else xpos := (mWidth-Length(mText)*8) div 2;
+
+         if (mVAlign < 0) then ypos := 0
+    else if (mVAlign > 0) then ypos := mHeight-8
+    else ypos := (mHeight-8) div 2;
+
+    drawText8(gx+xpos, gy+ypos, mText, 255, 255, 255);
+  end;
+end;
+
+
+function THCtlTextLabel.mouseEvent (var ev: THMouseEvent): Boolean;
+var
+  lx, ly: Integer;
+begin
+  result := inherited mouseEvent(ev);
+  if not result and toLocal(ev.x, ev.y, lx, ly) then
+  begin
+    result := true;
+  end;
+end;
+
+
+function THCtlTextLabel.keyEvent (var ev: THKeyEvent): Boolean;
+begin
+  result := inherited keyEvent(ev);
+end;
+
+
+initialization
+  registerCtlClass(THCtlBox, 'box');
+  registerCtlClass(THCtlHBox, 'hbox');
+  registerCtlClass(THCtlVBox, 'vbox');
+  registerCtlClass(THCtlSpan, 'span');
+  registerCtlClass(THCtlTextLabel, 'label');
 end.