2dglib.pkg

Go to the documentation of this file.

// -- processed by [filterPKG] --
/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2009 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

/* ********************************************************************************************* /
  Graphic / os mixed 2D library
  
  Version: 1.0
  Author: Bastien BOURINEAU / I-maginer
  Last update: 05.11.2010

  TODO :
  - size bar (jauge)
  
/ ********************************************************************************************* */

// Doxygen groups

/* ********************************************************************************************* /
  Default resources
/ ********************************************************************************************* */
var iG2DDEFAULTBACKGROUNDCOLOR=0x373737;
var iG2DDEFAULTFONTCOLOR=0x0;
var iG2DDEFAULTFRAMEFONTCOLOR=0xffffff;

var iG2DDEFAULTMODULEEDITORBGCOLOR=0x7d7d7d;
var iG2DDEFAULTMODULEEDITORDOTCOLOR=0xffffff;
var iG2DDEFAULTMODULEEDITORBOXBORDEROFFCOLOR=0xeeeeee;
var iG2DDEFAULTMODULEEDITORBOXBORDERONCOLOR=0xffffff;
var iG2DDEFAULTMODULEEDITORBOXOFFCOLOR=0x373737;
var iG2DDEFAULTMODULEEDITORBOXONCOLOR=0x888888;
var iG2DDEFAULTMODULEEDITORBOXTEXTONCOLOR=0xffffff;
var iG2DDEFAULTMODULEEDITORBOXTEXTOFFCOLOR=0xeeeeee;
var iG2DDEFAULTMODULEEDITORLINKOFFCOLOR=0xaaaaaa;
var iG2DDEFAULTMODULEEDITORLINKONCOLOR=0xffffff;
var iG2DDEFAULTMODULEEDITORROUNDLINKSIZE=24;
var iG2DDEFAULTMODULEEDITORBORDERWIDTH=1;

var sG2DDEFAULTRESOURCESPATH="tools/os3dlib/res/";

var sG2DHSIZECURSOR="valuesupdown_cursor.bmp";
var sG2DHCOLORPICKERCURSOR="colorpicker_cursor.bmp";

var sG2DDEFAULTCHKTAB="edit/chktab.png";
var sG2DDEFAULTCLOSETAB="edit/btnclosetab.png";
var sG2DDEFAULTBTNTABLEFT="edit/btnleft.png";
var sG2DDEFAULTBTNTABRIGHT="edit/btnright.png";
var sG2DDEFAULTBTNVALUP="edit/btnup.png";
var sG2DDEFAULTBTNVALDOWN="edit/btndown.png";
var sG2DDEFAULTBTNCOLORPICKER="edit/btncolorpicker.png";

var sG2DDEFAULTCHKFRAMEFOLD="edit/chkframeminmax.png";

var sG2DCOLORMAP="edit/work.png";
var sG2DCOLORMAPCROSS="edit/cross.png";


/* ********************************************************************************************* /
  structs
/ ********************************************************************************************* */
struct EdTheme{

  EDT_channel (Chn);
  EDT_iToolBarColor (I);
  EDT_lAlphaResources ([[S AlphaBitmap] r1]);
  
  EDT_cursorColorPicker (ObjCursor);
  EDT_sColorMap (S);
  EDT_abmpColorMapCross (AlphaBitmap);
  EDT_abmpColorMapPickerBtn (AlphaBitmap);
  
  EDT_iTabBarColor (I);  
  EDT_abmpTabCheck (AlphaBitmap);
  EDT_abmpTabClose (AlphaBitmap);
  EDT_abmpTabLeft (AlphaBitmap);
  EDT_abmpTabRight (AlphaBitmap);
  EDT_fontTab (ObjFont);
  EDT_iTabFontColor (I);
  
  EDT_cursorSize (ObjCursor);  
  EDT_abmpValUp (AlphaBitmap);
  EDT_abmpValDown (AlphaBitmap);
  
  EDT_abmpFrameFold (AlphaBitmap);
  EDT_sFrameFontName (S);
  EDT_iFrameFontSize (I);
  EDT_iFrameFontColor (I);
  EDT_iFrameBarColor (I);
  EDT_iFrameBarHeight (I);
  
  EDT_fontToolTip (ObjFont);
  
  EDT_fontModuleEditor (ObjFont);
  EDT_iModuleEditorBg (I);
  EDT_iModuleEditorDot (I);
  EDT_iModuleEditorBoxOff (I);
  EDT_iModuleEditorBoxOn (I);
  EDT_iModuleEditorBoxTextOff (I);
  EDT_iModuleEditorBoxTextOn (I);
  EDT_iModuleEditorLinkOff (I);
  EDT_iModuleEditorLinkOn (I);
  EDT_iModuleEditorRLinkSize (I);
  EDT_iModuleEditorBorderWidth (I);
  EDT_iModuleEditorBoxBorderOff (I);
  EDT_iModuleEditorBoxBorderOn (I
    
  );
};
typedef struct mkEdTheme EdTheme;


typeof EdDefaultTheme=EdTheme;


struct EdTreeItem{

  EDTITEM_item (ObjTreeItem);
  EDTITEM_sLabel (S);
  EDTITEM_sValue (S);
  EDTITEM_iType (I);
  EDTITEM_father (EdTreeItem);
  EDTITEM_bmpIdx (BitmapIndex);
  EDTITEM_lSons ([EdTreeItem r1]
  
  );
};
typedef struct mkEdTreeItem EdTreeItem;


struct EdControl{

  EDC_channel (Chn);
  EDC_father (EdWindow);
  EDC_resizeFlag (I);
  EDC_theme (EdTheme);
  EDC_coords ([I I I I I I]);
  EDC_label (ObjText);
  EDC_text (ObjText);
  EDC_editText (ObjText);
  EDC_editLine (ObjText);
  EDC_editFloat ([ObjText ObjContainer CompRollOver CompRollOver F F F I I ObjCursor I fun [EdControl F] I fun [EdControl F] I]);
  EDC_button (ObjButton);
  EDC_colorButton ([ObjButton ObjBitmap EdWindow I I fun[EdControl I] I]);
  EDC_check (ObjCheck);
  EDC_list ([ObjList [[I [S [[S r1] I]]] r1]]);
  EDC_tree ([ObjTree [[[ObjTreeItem EdTreeItem] r1] [[S EdTreeItem] r1] ObjBitmapList [[S BitmapIndex] r1]] EdTreeItem EdTreeItem fun [EdControl EdTreeItem EdTreeItem S I] I]);
  EDC_bitmap ([ObjContainer AlphaBitmap CompBitmap S I]);
  EDC_select (ObjBox);
  EDC_bitmapList ([ObjContainer I I I [[I [AlphaBitmap CompBitmap CompBitmap S S]] r1] fun [EdControl S I I] I fun [EdControl S I I] I]);
  EDC_modulesEditor (EdModuleEditor);
  EDC_view3d (V3Dview
  
  );
};
typedef struct mkEdControl EdControl;


struct EdModuleEditor{

  EDM_channel (Chn);
  EDM_winScroll (EdWindow);
  EDM_winDmi (EdWindow);
  EDM_bmpBack (EdControl);
  EDM_cont (ObjContainer);
  EDM_abmpLinks (AlphaBitmap);
  EDM_bmpLinks (CompBitmap);
  EDM_node (ObjNode);
  EDM_iSnap (I);
  EDM_iBoxMode (I);
  EDM_moveCoords ([I I]);
  EDM_sizeSurface ([I I]);
  EDM_iLinkMode (I);
  EDM_iLinkInfos ([S r1]);
  EDM_selectedBox ([EdModuleBox r1]);
  EDM_mnuBox (EdModuleBox);
  EDM_selectedRoundLink (EdModuleRoundLink);
  EDM_lBox ([[S EdModuleBox] r1]);
  EDM_lLinks ([EdModuleLink r1]);
  EDM_lRoundLinks ([EdModuleRoundLink r1]);
  EDM_cbRoundLinkClick (fun [EdControl EdModuleRoundLink I I] I);
  EDM_cbRoundLinkUnClick (fun [EdControl EdModuleRoundLink I I] I);
  EDM_cbRoundLinkDbClick (fun [EdControl EdModuleRoundLink I I] I);
  EDM_cbRoundLinkDestroy (fun [EdControl EdModuleRoundLink] I);
  EDM_cbRoundLinkUpdate (fun [EdControl EdModuleRoundLink] I);
  EDM_cbBoxSelect (fun [EdControl EdModuleBox] I);
  EDM_cbBoxClick (fun [EdControl EdModuleBox I I] I);
  EDM_cbBoxUnClick (fun [EdControl EdModuleBox I I] I);
  EDM_cbBoxDbClick (fun [EdControl EdModuleBox I I] I);
  EDM_cbBoxMove (fun [EdControl EdModuleBox I I] I);
  EDM_cbBoxMenu (fun [EdControl EdModuleBox [S r1] [S r1]] I);
  EDM_cbClick (fun [EdControl I I I I] I);
  EDM_cbUnClick (fun [EdControl I I I I] I);
  EDM_cbDbClick (fun [EdControl I I I I] I);
  EDM_cbKeyDown (fun [EdControl I I] I);
  EDM_cbKeyUp (fun [EdControl I] I
  
  );
};
typedef struct mkEdModuleEditor EdModuleEditor;


struct EdModuleBox{

  EDB_father (EdModuleEditor);
  EDB_sName (S);
  EDB_lParams ([S r1]);
  EDB_compBmp (CompBitmap);
  EDB_alphaBmp (AlphaBitmap);
  EDB_bmpOn (ObjBitmap);
  EDB_bmpOff (ObjBitmap);
  EDB_node (ObjNode);
  EDB_pos ([I I]);
  EDB_bHasMoved (I);
  EDB_iKeybState (I);
  EDB_iWidth (I);
  EDB_iHeight (I);
  EDB_lMenus ([[I [[S r1] r1]] r1]);
  EDB_tooltip ([ObjContainer CompText]);
  EDB_iFlags (I);
  EDB_bState (I

  );
};
typedef struct mkEdModuleBox EdModuleBox;


struct EdModuleRoundLink{

  EDRL_srcModuleBox (EdModuleBox);
  EDRL_dstModuleBox (EdModuleBox);
  EDRL_lLinks ([EdModuleLink r1]);
  EDRL_compBmp (CompBitmap);
  EDRL_alphaBmp (AlphaBitmap);
  EDRL_bmpOn (ObjBitmap);
  EDRL_bmpOff (ObjBitmap);
  EDRL_node (ObjNode);
  EDRL_tooltip ([ObjContainer CompText]);
  EDRL_iFlag (I);
  EDRL_bState (I

  );
};
typedef struct mkEdModuleRoundLink EdModuleRoundLink;


struct EdModuleLink{

  EDL_srcModuleBox (EdModuleBox);
  EDL_dstModuleBox (EdModuleBox);
  EDL_lParams ([S r1]);
  EDL_sParams (S);
  
  EDL_bState (I

  );
};
typedef struct mkEdModuleLink EdModuleLink;


struct EdWindow{

  EDW_channel (Chn);
  EDW_father (EdWindow);
  EDW_fatherWin (ObjWin);
  EDW_lSons ([EdWindow r1]);
  EDW_win (ObjWin);
  EDW_virtualWin (ObjWin);
  EDW_bIsAx (I);
  EDW_lToolbar ([EdToolBar r1]);
  EDW_resizeFlag (I);
  EDW_bMinimize (I);
  EDW_tMdecal ([I I]);
  EDW_coords ([I I I I I I]);
  EDW_tLastCursorPos ([I I]);
  EDW_modeFlag (I);                // 0 normal 1 popup 2 inside popup 4 frame with title bar 8 group
  EDW_bVisible (I);
  EDW_lControl ([EdControl r1]);
  EDW_cbSize (fun [EdWindow I I] I);
  EDW_cbMove (fun [EdWindow I I] I);
  EDW_cbVirtualSize (fun [EdWindow I I] I);
  EDW_cbVirtualMove (fun [EdWindow I I] I);
  EDW_cbDestroy (fun [EdWindow] I);
  EDW_cbClose (fun [EdWindow] I);
  EDW_cbKeyDown (fun [EdWindow I I] I);
  EDW_cbKeyUp (fun [EdWindow I] I);
  EDW_cbDrop (fun [EdWindow I I [P r1]] I
  
  );
};
typedef struct mkEdWindow EdWindow;


var EDWIN_RESIZE_NONE=0; 
var EDWIN_RESIZE_LW=1;           // left border is at a flexible distance from the left border of the parent zone
var EDWIN_RESIZE_MW=2;           // width is a flexible value
var EDWIN_RESIZE_RW=4;           // right border is at a flexible distance from the right border of the parent zone
var EDWIN_RESIZE_LH=8;           // top border is at a flexible distance from the top border of the parent zone
var EDWIN_RESIZE_MH=16;          // height is a flexible value
var EDWIN_RESIZE_RH=32;          // bottom border is at a flexible distance from the bottom border of the parent zone
var EDWIN_RESIZE_ALL=64;         // all flexible
var EDWIN_DIALOG=1;
var EDWIN_POPUP=2;
var EDWIN_FRAME=4;
var EDWIN_GROUP=8;
var EDWIN_TAB=16;
var EDWIN_MODAL=32;
proto crEdWindow=fun [Chn EdWindow I I I I I I I S] EdWindow;
proto dsEdWindow=fun [EdWindow] I;
proto resizeEdWindowVirtualSize=fun [EdWindow] I;
proto getEdWindowToolBarSize=fun [EdWindow] [I I];
proto setEdWindowVisible=fun [EdWindow I] I;
proto dsEdWindowCtrlList=fun [[EdControl r1]] I;


struct EdToolBar{

  ETB_channel (Chn);
  ETB_win (ObjWin);
  ETB_cont (ObjContainer);
  ETB_pos ([I I]);
  ETB_size ([I I]);
  ETB_modeflag (I);
  ETB_iBgColor (I);
  ETB_iHmargin (I);
  ETB_iVmargin (I);
  ETB_iCurrentLpos (I);
  ETB_iCurrentRpos (I);
  ETB_iCurrentTpos (I);
  ETB_iCurrentBpos (I);  
  ETB_lButton ([CompRollOver r1]);    // cb ctrl btn mask
  ETB_lBmp ([CompBitmap r1]);      // cb ctrl btn mask isdbclick
  ETB_lCheck ([CompCheck r1]);       // cb ctrl btn mask state
  ETB_lText ([[CompText ObjFont] r1]);        // cb ctrl btn mask
  ETB_tabBar (EdTabBar);  
  ETB_lTooltip ([[ObjNode [ObjContainer CompText]] r1]);
  ETB_lControl ([[ObjNode I] r1]);
  ETB_fontTooltip (ObjFont);
  ETB_bVisible (I
  
);
};
typedef struct mkEdToolBar EdToolBar;


var ETB_HORIZONTAL=1;
var ETB_VERTICAL=2;

var ETB_ALIGN_LEFT=1;
var ETB_ALIGN_RIGHT=2;
var ETB_ALIGN_TOP=4;
var ETB_ALIGN_BOTTOM=8;


struct EdTabBar{

  ETABBAR_channel (Chn);
  ETABBAR_cont (ObjContainer);
  ETABBAR_node (ObjNode);
  ETABBAR_targetWin (EdWindow);
  ETABBAR_iHeight (I);           // height of the toolbar
  ETABBAR_pos ([I I]);
  ETABBAR_size ([I I]);
  ETABBAR_rightPos (I);
  ETABBAR_iMargin (I);
  ETABBAR_iCurrentLpos (I);
  ETABBAR_lTab ([EdTab r1]);
  ETABBAR_theme (EdTheme);
  ETABBAR_lastTab (EdTab);
  ETABBAR_currentTab (EdTab);
  ETABBAR_contScroll (ObjContainer);
  ETABBAR_btnScrollL (CompRollOver);
  ETABBAR_btnScrollR (CompRollOver);
  ETABBAR_iScrollPos (I
  
);
};
typedef struct mkEdTabBar EdTabBar;


struct EdTab{

  ETAB_channel (Chn);
  ETAB_tabBar (EdTabBar);
  ETAB_abmpTab (AlphaBitmap);
  ETAB_sName (S);
  ETAB_win (EdWindow);
  ETAB_chk (CompCheck);
  ETAB_closeBtn (CompRollOver);
  
  ETAB_cbShow (fun [EdTab] I);
  ETAB_cbHide (fun [EdTab] I);
  ETAB_cbFocused (fun [EdTab] I);
  ETAB_cbClosed (fun [EdTab] I);
  ETAB_modeFlag (I);
  ETAB_bState (I
  
);
};
typedef struct mkEdTab EdTab;

proto focusEdTab=fun [EdTabBar EdTab] I;
proto dsEdTab=fun [EdTabBar EdTab] I;

var ETAB_CLOSEBTN=1;

/* ********************************************************************************************* /
  Common part
/ ********************************************************************************************* */

G2Drgba2bgra(c){
let get_rgba c -> [r g b a] in 
    make_rgba b g r a;
}


G2DgetAplhaFromColor(c){
let get_rgba c -> [r g b a] in
    a;
}


G2Dbgra2bgr(c){
let get_rgba c -> [b g r a] in 
    make_rgb b g r ;
}


G2Drgba2rgb(c){
let get_rgba c -> [r g b a] in 
    make_rgb r g b ;
}


G2Dbgr2bgra(c, a){
let c & 255 -> b in
  let (c>>8) &  255 -> g in  
  let (c>>16) & 255 -> r in
    make_rgba b g r a;
}


G2Drgb2rgba(c, a){
let c & 255 -> r in
  let (c>>8) &  255 -> g in
  let (c>>16) & 255 -> b in  
    make_rgba r g b a;
}


G2Drgb2bgr(c){
let c & 255 -> r in
  let (c>>8) &  255 -> g in
  let (c>>16) & 255 -> b in  
    make_rgb b g r;
}


G2Dgetbgr(c){
if c == nil then
    [0 0 0]
  else
    [(c>>16)&255 (c>>8)&255 c&255];
}


G2Dgetrgb(c){
if c == nil then
    [0 0 0]
  else
    [c&255 (c>>8)&255 (c>>16)&255];
}


G2Dhsv2rgb(h, s, v){
/* rgb 24bits, 0 <= h <= 360, 0 <= s <= 1, 0 <= v <= 1 */
  set v= v*.itof 255;
  if s==itof 0
  then
    (ftoi v)+((ftoi v)<<8)+((ftoi v)<<16)
  else
  {
    while h >=. itof 360 do set h = h -. itof 360;
    while h <. itof 0 do set h = h +. itof 360;
    set h = h /. itof 60;

    let ftoi h -> i in
    let h -. itof i -> f in
    let v *. ((itof 1) -. s) -> p in
    let v *. ((itof 1) -. s *. f) -> q in
    let v *. ((itof 1) -. s *. ((itof 1) -. f)) -> t in
    if i==0
    then
      (ftoi v)+((ftoi t)<<8)+((ftoi p)<<16)
    else if i==1
    then
      (ftoi q)+((ftoi v)<<8)+((ftoi p)<<16)
    else if i==2
    then
      (ftoi p)+((ftoi v)<<8)+((ftoi t)<<16)
    else if i==3
    then
      (ftoi p)+((ftoi q)<<8)+((ftoi v)<<16)
    else if i==4
    then
      (ftoi t)+((ftoi p)<<8)+((ftoi v)<<16)
    else if i==5
    then
      (ftoi v)+((ftoi p)<<8)+((ftoi q)<<16)
    else
      nil
  };
}


G2Drgb2hsv(c){
/* c = 24 bits color */
  let (c>>16) & 255 -> b in
  let (c>>8) &  255 -> g in
  let c & 255 -> r in
  let
    if r>g
    then
      if b>r
      then
        b
      else
        r
    else
      if b>g
      then
        b
      else
        g
  -> mx in
  let
    if r<g
    then
      if b<r
      then
        b
      else
        r
    else
      if b<g
      then
        b
      else
        g
  -> mn in
  let itof mx-mn -> delta in
  let
    if mx==0
    then
      itof 0
    else
      (itof mx-mn) /. itof mx
  -> s in
  let
    if (s>.itof 0) || (s<.itof 0) || (delta>.itof 0) || (delta<.itof 0) /* s != 0 || delta != 0 */
    then
      (itof 60) *.
        if r==mx
        then
          (itof g-b)/.delta
        else if g==mx
        then
          (itof 2)+.(itof b-r)/.delta
        else (itof 4)+.(itof r-g)/.delta
    else
      itof 0
  -> h in
  [
    // h
    if h<.itof 0 then h+.itof 360 else h
    // s
    s
    // v
    (itof mx)/.itof 255
  ];
}


G2DgetFtoA(float, nb){
let if float == nil then 0.0 else float -> float in
  let ftoa float -> sf in
  let if nb == 0 || nb == nil then 0 else 1 + nb -> nb0 in
    substr sf 0 ((strfind "." sf 0) + nb0);
}


G2Dlcat(p, q){
if p==nil
  then
    q
  else let p -> [h nxt] in
    h::G2Dlcat nxt q;
}


G2DisInList(p, q){
if p==nil
  then
    0
  else let p -> [h nxt] in
    if h == q then
      1
    else G2DisInList nxt q;
}


G2DremoveFromList(l, elt){
if l==nil
  then
    nil
  else
    let hd l -> elm in
    if elm == elt then
      tl l
    else
      (hd l)::G2DremoveFromList tl l elt;
}


G2DremoveStringFromList(l, elt){
if l==nil
  then
    nil
  else
    let hd l -> elm in
    if !strcmpi elm elt then
      tl l
    else
      (hd l)::G2DremoveStringFromList tl l elt;
}


G2DremoveEdIdxFromList(l, idx){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if id == idx then
      tl l
    else
      (hd l)::G2DremoveEdIdxFromList tl l idx;
}


G2DremoveEdSidFromList(l, sid){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if (!strcmp id sid) then
      tl l
    else
      (hd l)::G2DremoveEdSidFromList tl l sid;
}


G2DremoveEdSidFromListi(l, sid){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if (!strcmpi id sid) then
      tl l
    else
      (hd l)::G2DremoveEdSidFromListi tl l sid;
}


G2DgetElemFromListByIndex(l, idx){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if idx == id then
      hd l
    else
      G2DgetElemFromListByIndex tl l idx
  ;
}


G2DgetStrWidth(font,str){
let _GETstringSize font str-> [width _] in
    width
;
}


G2DgetStringSize2(font, txtList, w, h){
if txtList == nil then [w+1 h]
  else let txtList -> [first next] in
       let _GETstringSize font first -> [nw nh] in
         G2DgetStringSize2 font next (if nw>w then nw else w) (nh+h)
  ;
}


G2DgetStringSize(font, str){
G2DgetStringSize2 font (lineextr str) 0 0;
}


G2DgetAbreviation(str,size,font,endstr){
if (G2DgetStrWidth font str) <= size then
    [(G2DgetStrWidth font str) str]
  else
    G2DgetAbreviation (strcat (substr str 0 ((strlen str)-4)) endstr) size font endstr
;
}


G2DcreateAlphaBitmap(alphabmp, x, y, left, right, ww, hh, w, h){
let _GETalphaBitmapSize alphabmp -> [aw ah] in
  if aw == w && ah == h then
    alphabmp
  else
  let _GETalphaBitmaps alphabmp -> [_ bmpalpha] in
  let _FILLbitmap _CRbitmap _channel w h 0 -> bmp in
  let _FILLbitmap8 _CRbitmap8 _channel w h 0 -> bmp8 in  
  (
    // create fixed part of bitmap
    _CPalphaBitmap  bmp     left      0   alphabmp     x    y   ww+x hh+y ; /* haut gauche */
    _CPalphaBitmap  bmp     left      h-hh  alphabmp     x    y+hh  ww+x hh+y ; /* bas gauche  */
    _CPalphaBitmap  bmp   w-(ww+right)    0   alphabmp aw-(ww+x)     y  ww+x hh+y ; /* haut droite */
    _CPalphaBitmap  bmp   w-(ww+right)  h-hh  alphabmp aw-(ww+x)  y+hh  ww+x hh+y ; /* bas droite  */
    // create streched part of bitmap
    _SCPalphaBitmap bmp  left     hh-1  ww+left-1 h-hh  alphabmp  x   hh+y    ww+x      hh+y ; /* gauche */   
    _SCPalphaBitmap bmp  w-(ww+right) hh    w-(right+1) h-hh  alphabmp  aw-ww+x hh+y  aw-1+x      hh+y ; /* droite */        
    _SCPalphaBitmap bmp  ww-1+left     0   w-(ww+right)    hh-1  alphabmp      ww+x       y    ww+x      hh+y ; /* haut   */       
    _SCPalphaBitmap bmp  ww+left-1  h-hh   w-(ww+right)   h-1  alphabmp      ww+x   ah-(hh+y)    ww+x    ah-(1+y) ; /* bas    */
    _SCPalphaBitmap bmp  ww+left-1  hh-1   w-(ww+right) h-hh  alphabmp      ww+x      hh+y    ww+x      hh+y ; /* centre */


    // create fixed part of bitmap
    _CPbitmap8  bmp8     left     0   bmpalpha     x    y   ww+x hh+y nil; /* haut gauche */
    _CPbitmap8  bmp8     left     h-hh  bmpalpha     x    y+hh  ww+x hh+y nil; /* bas gauche  */
    _CPbitmap8  bmp8    w-(ww+right)    0   bmpalpha aw-(ww+x)     y  ww+x hh+y nil; /* haut droite */
    _CPbitmap8  bmp8    w-(ww+right)  h-hh  bmpalpha aw-(ww+x)  y+hh  ww+x hh+y nil; /* bas droite  */
    // create streched part of bitmap
    _SCPbitmap8 bmp8  left      hh-1  ww+left-1 h-hh  bmpalpha  x   hh+y    ww+x      hh+y nil; /* gauche */   
    _SCPbitmap8 bmp8  w-(ww+right)  hh    w-(right+1) h-hh  bmpalpha  aw-ww+x hh+y  aw-1+x      hh+y nil; /* droite */        
    _SCPbitmap8 bmp8  ww-1+left     0   w-(ww+right)    hh-1  bmpalpha      ww+x       y    ww+x      hh+y nil; /* haut   */       
    _SCPbitmap8 bmp8  ww+left-1  h-hh   w-(ww+right)   h-1  bmpalpha      ww+x   ah-(hh+y)    ww+x    ah-(1+y) nil; /* bas    */
    _SCPbitmap8 bmp8  ww+left-1  hh-1   w-(ww+right) h-hh  bmpalpha      ww+x      hh+y    ww+x      hh+y nil; /* centre */
            
    let _CRalphaBitmap _channel bmp bmp8 nil nil  -> nalphabmp in
    (
        _DSalphaBitmap alphabmp ;
        _DSbitmap bmp ;
        _DSbitmap8 bmp8 ;
        nalphabmp
    ) ;
  );
}


G2DcreateAlphaBitmapRollover(alphabmp, x, y, left, right, ww, hh, w, h){
let _GETalphaBitmapSize alphabmp -> [aw ah] in
  let ah / 5 -> bmph in

  let _FILLbitmap _CRbitmap _channel w h nil -> bmp in
  let _FILLbitmap8 _CRbitmap8 _channel w h nil -> bmp8 in
  let _GETalphaBitmaps alphabmp -> [_ bmpalpha8] in
  (
    // create fixed part of bitmap
    _CPalphaBitmap  bmp   left          0     alphabmp x          y         ww+x hh+y ; /* haut gauche */
    _CPalphaBitmap  bmp   left          h-hh  alphabmp x          y+bmph-hh ww+x hh+y ; /* bas gauche  */
    _CPalphaBitmap  bmp   w-(ww+right)  0     alphabmp aw-(ww+x)  y         ww+x hh+y ; /* haut droite */
    _CPalphaBitmap  bmp   w-(ww+right)  h-hh  alphabmp aw-(ww+x)  y+bmph-hh ww+x hh+y ; /* bas droite  */

    // create streched part of bitmap
    _SCPalphaBitmap bmp  left         hh-1  ww+left-1    h-hh alphabmp  x       hh+y      ww+x      hh+y ; /* gauche */   
    _SCPalphaBitmap bmp  w-(ww+right) hh    w-(right+1)  h-hh alphabmp  aw-ww+x hh+y      aw-1+x    hh+y ; /* droite */        
    _SCPalphaBitmap bmp  ww-1+left    0     w-(ww+right) hh-1 alphabmp  ww+x    y         aw-(ww+x) hh+y ; /* haut   */       
    _SCPalphaBitmap bmp  ww+left-1    h-hh  w-(ww+right) h-1  alphabmp  ww+x    y+bmph-hh aw-(ww+x) y+bmph ; /* bas    */
    _SCPalphaBitmap bmp  ww+left-1    hh-1  w-(ww+right) h-hh alphabmp  ww+x    hh+y      aw-(ww+x) hh+y ; /* centre */


    // create fixed part of bitmap
    _CPbitmap8  bmp8     left         0     bmpalpha8     x           y         ww+x hh+y nil; /* haut gauche */
    _CPbitmap8  bmp8     left         h-hh  bmpalpha8     x           y+bmph-hh ww+x hh+y nil; /* bas gauche  */
    _CPbitmap8  bmp8     w-(ww+right) 0     bmpalpha8     aw-(ww+x)   y         ww+x hh+y nil; /* haut droite */
    _CPbitmap8  bmp8     w-(ww+right) h-hh  bmpalpha8     aw-(ww+x)   y+bmph-hh ww+x hh+y nil; /* bas droite  */
    
    // create streched part of bitmap
    _SCPbitmap8 bmp8  left          hh-1  ww+left-1     h-hh  bmpalpha8 x       hh+y      ww+x      hh+y   nil; /* gauche */   
    _SCPbitmap8 bmp8  w-(ww+right)  hh    w-(right+1)   h-hh  bmpalpha8 aw-ww+x hh+y      aw-1+x    hh+y   nil; /* droite */        
    _SCPbitmap8 bmp8  ww-1+left     0     w-(ww+right)  hh-1  bmpalpha8 ww+x    y         aw-(ww+x) hh+y   nil; /* haut   */       
    _SCPbitmap8 bmp8  ww+left-1     h-hh  w-(ww+right)  h-1   bmpalpha8 ww+x    y+bmph-hh aw-(ww+x) y+bmph nil; /* bas    */
    _SCPbitmap8 bmp8  ww+left-1     hh-1  w-(ww+right)  h-hh  bmpalpha8 ww+x    hh+y      aw-(ww+x) hh+y   nil; /* centre */

    let _CRalphaBitmap _channel bmp bmp8 nil nil  -> nalphabmp in
    (
        _DSbitmap8 bmp8;
        _DSbitmap bmp ;
        nalphabmp
    ) ;
  );
}


G2DloadPngToBmp(chan, path){
let _LDalphaBitmap chan (_checkpack path) -> alpha in
  let _GETalphaBitmapSize alpha -> [w h] in
  let _FILLbitmap _CRbitmap chan w h 0xffffff -> newbmp in
    (
      if alpha == nil then nil else
        (
          _CPalphaBitmap newbmp 0 0 alpha 0 0 w h;
          _DSalphaBitmap alpha;
          newbmp;
        );
    );
}


G2DloadBmp(chan, path){
let _checkpack path -> file in
  let _LDbitmap chan file -> bmp in
  let if bmp == nil then _LDjpeg chan file else bmp -> bmp in
  let if bmp == nil then _LDtga chan file else bmp -> bmp in  
  let if bmp == nil then G2DloadPngToBmp chan path else bmp -> bmp in
    bmp;
}


G2DloadAlphaBmp(chan, path){
let _checkpack path -> file in
  let nil -> newalpha in
  (
    let _LDbitmap chan file -> bmp in
    let _LDjpeg chan file -> bmp2 in
    if bmp != nil then
    (
      let _GETbitmapSize bmp -> [w h] in
      let _FILLbitmap8 _CRbitmap8 chan w h 0 -> bmp8 in
      (
        set newalpha = _CRalphaBitmap chan bmp bmp8 0 0;
        _DSbitmap bmp;
        _DSbitmap8 bmp8;
      );
      0;
    )
    else if bmp2 != nil then
    (
      let _GETbitmapSize bmp2 -> [w h] in
      let _FILLbitmap8 _CRbitmap8 chan w h 0 -> bmp8 in
      (
        set newalpha = _CRalphaBitmap chan bmp2 bmp8 0 0;
        _DSbitmap bmp2;
        _DSbitmap8 bmp8;
      );
      0;
    )
    else
    (
      set newalpha = _LDalphaBitmap chan file;
      0;
    );
   
    newalpha;
  );
}


G2DstrechBitmap(chan, bmp, width, height, bcolor){
let _GETbitmapSize bmp -> [bw bh] in
  if (bw == width) && (bh == height) then bmp else
  let _FILLbitmap _CRbitmap chan width height bcolor -> newbmp in
  let if bh > bw then bh / bw else bw / bh -> ratio in
  let if bh > bw then height / ratio else width -> fw in
  let if bw > bh then width / ratio else height -> fh in
    _SCPbitmap newbmp ((width / 2) - (fw / 2)) ((height / 2) - (fh / 2)) ((width / 2) + (fw / 2)) ((height / 2) + (fh / 2)) bmp 0 0 bw bh nil
  ;
}


G2DcreateLayer(chan, w, h, border, bcolor, color, opacity){
// construction de la palette 8bit de niveau de gris
  let mktab 768 0 -> greypal in
  (
    let 0 -> i in
    let 0 -> c in
      while (i < 768) do
      (
        set greypal.(i) = c;
        set greypal.(i+1) = c;
        set greypal.(i+2) = c;
        set i = i+3; 
        set c = c+1;
      );
    
    let (255 * opacity) / 100 -> opcoef in
    let if !border then
        _FILLbitmap _CRbitmap chan w h color
        else
          (_DRAWrectangle 
          (_FILLbitmap (_CRbitmap chan w h) color)
          0 0 w h DRAW_SOLID border bcolor DRAW_INVISIBLE color)
    -> nodebmp in
    
    let if !border then
        _FILLbitmap8 (_SETbitmapPalette _CRbitmap8 chan w h greypal) (make_rgb opcoef opcoef opcoef)
        else
          (_DRAWrectangle8 
          (_FILLbitmap8 (_SETbitmapPalette _CRbitmap8 chan w h greypal) 0)
          0 0 w h DRAW_SOLID border 0xffffff DRAW_SOLID (make_rgb opcoef opcoef opcoef))    
    -> nodebmpalpha in
    let _CRalphaBitmap chan nodebmp nodebmpalpha nil nil -> alphabmp in
    (
      _DSbitmap nodebmp;
      _DSbitmap8 nodebmpalpha;
      alphabmp;
    );
  );
}


G2DsetLayer(chan, alphabmp, w, h, border, bcolor, color, opacity){
// construction de la palette 8bit de niveau de gris
  let mktab 768 0 -> greypal in
  let _GETalphaBitmaps alphabmp -> [buffer buffer8] in
  (
    let 0 -> i in
    let 0 -> c in
      while (i < 768) do
      (
        set greypal.(i) = c;
        set greypal.(i+1) = c;
        set greypal.(i+2) = c;
        set i = i+3; 
        set c = c+1;
      );
    
    let (255 * opacity) / 100 -> opcoef in
    let if !border then
        _FILLbitmap buffer color
        else
          (_DRAWrectangle 
          (_FILLbitmap buffer color)
          0 0 w h DRAW_SOLID border bcolor DRAW_INVISIBLE color)
    -> nodebmp in
    
    let if !border then
        _FILLbitmap8 (_SETbitmapPalette buffer8 greypal) (make_rgb opcoef opcoef opcoef)
        else
          (_DRAWrectangle8 
          (_FILLbitmap8 (_SETbitmapPalette buffer8 greypal) 0)
          0 0 w h DRAW_SOLID border 0xffffff DRAW_SOLID (make_rgb opcoef opcoef opcoef))    
    -> nodebmpalpha in
      alphabmp;
  );
}


/* ***************************** */
/*    Resize check with text     */
/* ***************************** */
G2DbBmp_HResize(resBmp,orgBmp,resBmp8,orgBmp8,nbCol,numCol,trans,borders){
let borders -> [wl wr ht hb] in
  let _GETbitmapSize resBmp -> [resW resH] in
  let resW/nbCol -> widthRes in
  let numCol*widthRes -> resPos in
  let _GETbitmapSize orgBmp -> [orgW orgH] in
  let orgW/nbCol -> widthOrg in
  let numCol*widthOrg -> orgPos in
  (
    _SCPbitmap resBmp resPos 0 resPos+wl-1 resH orgBmp orgPos 0 orgPos+wl-1 resH trans;
    _SCPbitmap resBmp resPos+wl 0 resPos+widthRes-wr-1 resH orgBmp orgPos+wl 0 orgPos+widthOrg-wr-1 resH trans;
    _SCPbitmap resBmp resPos+widthRes-wr 0 resPos+widthRes-1 resH orgBmp orgPos+widthOrg-wr 0 orgPos+widthOrg-1 resH trans;
    _SCPbitmap8 resBmp8 resPos 0 resPos+wl-1 resH orgBmp8 orgPos 0 orgPos+wl-1 resH trans;
    _SCPbitmap8 resBmp8 resPos+wl 0 resPos+widthRes-wr-1 resH orgBmp8 orgPos+wl 0 orgPos+widthOrg-wr-1 resH trans;
    _SCPbitmap8 resBmp8 resPos+widthRes-wr 0 resPos+widthRes-1 resH orgBmp8 orgPos+widthOrg-wr 0 orgPos+widthOrg-1 resH trans;
    if (numCol+1)==nbCol then
      0
    else
      G2DbBmp_HResize resBmp orgBmp resBmp8 orgBmp8 nbCol numCol+1 trans borders
   );
}


G2DbBmp_VResize(resBmp,orgBmp,resBmp8,orgBmp8,nbLine,numLine,trans,borders){
let borders -> [wl wr ht hb] in
  let _GETbitmapSize resBmp -> [resW resH] in
  let resH/nbLine -> heightRes in
  let numLine*heightRes -> resPos in
  let _GETbitmapSize orgBmp -> [orgW orgH] in
  let orgH/nbLine -> heightOrg in
  let numLine*heightOrg -> orgPos in
  (
    _SCPbitmap resBmp 0 resPos resW resPos+ht-1 orgBmp 0 orgPos resW orgPos+ht-1 trans;
    _SCPbitmap resBmp 0 resPos+ht resW resPos+heightRes-hb-1 orgBmp 0 orgPos+ht resW orgPos+heightOrg-hb-1 trans;
    _SCPbitmap resBmp 0 resPos+heightRes-hb resW resPos+heightRes-1 orgBmp 0 orgPos+heightOrg-hb resW orgPos+heightOrg-1 trans;
    _SCPbitmap8 resBmp8 0 resPos resW resPos+ht-1 orgBmp8 0 orgPos resW orgPos+ht-1 trans;
    _SCPbitmap8 resBmp8 0 resPos+ht resW resPos+heightRes-hb-1 orgBmp8 0 orgPos+ht resW orgPos+heightOrg-hb-1 trans;
    _SCPbitmap8 resBmp8 0 resPos+heightRes-hb resW resPos+heightRes-1 orgBmp8 0 orgPos+heightOrg-hb resW orgPos+heightOrg-1 trans;
    
    if (numLine+1)==nbLine then
      0
    else
      G2DbBmp_VResize resBmp orgBmp resBmp8 orgBmp8 nbLine numLine+1 trans borders
   );
}


G2DbBmp_DrawText(bmp,text,tabl,size,pos,colors,numLine,numCol){
let text -> [txt font] in
  let tabl -> [nbLine nbCol] in
  let pos -> [xpos ypos] in
  let size -> [width height] in
  (
    let hd hd colors -> coul in
      if coul!=-1 then
        _DRAWtext bmp font xpos+(width*numCol) ypos+(height*numLine) TD_TOP|TD_LEFT coul txt
      else
        nil;
    if (numLine+1)==nbLine then
      if (numCol+1)==nbCol then
        0
      else
        G2DbBmp_DrawText bmp text tabl size pos (tl colors) 0 numCol+1
    else
      G2DbBmp_DrawText bmp text tabl size pos ((tl hd colors)::(tl colors)) numLine+1 numCol
  );
}


// construct the alphaBitmap for the CompChecks of the items' Menu
G2DbBmp_stretchButtonText(chan,text,size,colors,borders,tabl,img,right){
let text -> [txt font] in
  let size -> [width height] in
  let colors -> [trans write] in
  let borders -> [wl wr ht hb] in
  let tabl -> [nbLine nbCol] in
  let _GETalphaBitmaps img -> [Bmp Bmp8] in
  let _GETbitmapSize Bmp -> [bmpW bmpH] in

  // creation of the two destination bitmap
  let _CRbitmap chan (width+right)*nbCol bmpH -> tempBmp in
  let _CRbitmap8 chan (width+right)*nbCol bmpH -> tempBmp8 in
  (
    G2DbBmp_HResize tempBmp Bmp tempBmp8 Bmp8 nbCol 0 nil borders;
    let _CRbitmap chan (width+right)*nbCol nbLine*height -> temp2Bmp in
    let _CRbitmap8 chan (width+right)*nbCol nbLine*height -> temp2Bmp8 in
    (
      G2DbBmp_VResize temp2Bmp tempBmp temp2Bmp8 tempBmp8 nbLine 0 nil borders;
      
      // calculation of the position of the text
      let _GETstringSize font txt -> [wtxt htxt] in
      let if width-(wl+wr)>wtxt then ((width-(wl+wr)-wtxt)/2)+wl else wl -> xpos in
      let if height>htxt then height-htxt-hb else ht -> ypos in
      (
        // draw of the text in the different state of the bitmap
        G2DbBmp_DrawText temp2Bmp text tabl [(width + right) height] [xpos ypos] write 0 0;
  
        //_SAVEjpeg temp2Bmp _getmodifypack (strcatn "testBBMP"::txt::".jpg"::nil) 80;

        // creation of the final alphabitmap
        let _CRalphaBitmap chan temp2Bmp temp2Bmp8 nil trans -> newalpha in
        (
          _DSbitmap tempBmp;
          _DSbitmap8 tempBmp8;
          _DSbitmap temp2Bmp;
          _DSbitmap8 temp2Bmp8;
          
          newalpha;
        );
      )
    )
  );
}


G2DcbResizeNode(cbmp, p, w, h, oldval){
if w < 1 || h < 1 then nil else
  let p -> [oldalpha color opcoef] in
  (
    _DSalphaBitmap oldalpha;
     
    let oldval -> [ox oy ow oh] in
    let _FILLbitmap _CRbitmap _channel w h color -> nodebmp in
    let _FILLbitmap8 _CRbitmap8 _channel w h (make_rgb opcoef opcoef opcoef) -> nodebmpalpha in
    let _CRalphaBitmap _channel nodebmp nodebmpalpha nil nil -> alphamainnode in
    (
      _DSbitmap nodebmp;
      _DSbitmap8 nodebmpalpha;
      [alphamainnode [ox oy w h]]
    );
  );
}
  

G2DcreateNode(container, node, pos, width, height, flags, color, opacity, inline, linecolor){
let (255 * opacity) / 100 -> opcoef in
  
  let if inline != 0 && inline != nil then
        (_DRAWrectangle 
        (_FILLbitmap (_CRbitmap _channel width height) color)
        0 0 width height DRAW_SOLID inline linecolor DRAW_INVISIBLE color)
      else
        _FILLbitmap _CRbitmap _channel width height color
  -> nodebmp in
  
  let if inline != 0 && inline != nil then
        (_DRAWrectangle8 
        (_FILLbitmap8 (_CRbitmap8 _channel width height) (make_rgb opcoef opcoef opcoef))
        0 0 width height DRAW_SOLID inline (make_rgb 255 255 255) DRAW_INVISIBLE (make_rgb opcoef opcoef opcoef))    
      else
        _FILLbitmap8 _CRbitmap8 _channel width height (make_rgb opcoef opcoef opcoef)
  -> nodebmpalpha in
  
  let _CRalphaBitmap _channel nodebmp nodebmpalpha nil nil -> alphamainnode in
  let _CBcompBitmapResizeResource _CRcompBitmap _channel container node pos flags|OBJ_LH_FLEX|OBJ_MH_FLEX OBJ_CONTAINER_CLICK|OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_DBLCLICK|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_MOVE alphamainnode 0 0 width height  @G2DcbResizeNode [alphamainnode color opcoef] -> nodeback in
  (
    _DSbitmap nodebmp;
    _DSbitmap8 nodebmpalpha;
    _CONVERTcompBitmapToObjNode nodeback;
  );
}


makeEdThemeResources(chan){
let mkEdTheme [chan nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> themestr in
  (
    set themestr.EDT_iToolBarColor = iG2DDEFAULTBACKGROUNDCOLOR;
    set themestr.EDT_iTabBarColor = iG2DDEFAULTBACKGROUNDCOLOR;

    let _LDbitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DHCOLORPICKERCURSOR) -> bmp in
    let _GETbitmapSize bmp -> [bw bh] in
    let _CRcursor themestr.EDT_channel bmp (bw / 2) (bh / 2) 0x000000 0xffffff -> cursor in
      set themestr.EDT_cursorColorPicker = cursor;
    
    set themestr.EDT_sColorMap = (strcat sG2DDEFAULTRESOURCESPATH sG2DCOLORMAP);
    set themestr.EDT_abmpColorMapCross = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DCOLORMAPCROSS);
    set themestr.EDT_abmpColorMapPickerBtn = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTBTNCOLORPICKER);

    set themestr.EDT_abmpTabCheck = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTCHKTAB);
    set themestr.EDT_abmpTabClose = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTCLOSETAB);
    set themestr.EDT_abmpTabLeft = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTBTNTABLEFT);
    set themestr.EDT_abmpTabRight = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTBTNTABRIGHT);
    
    set themestr.EDT_iTabFontColor = iG2DDEFAULTFONTCOLOR;
    set themestr.EDT_fontTab = _CRfont themestr.EDT_channel 9 0 FF_PIXEL "Arial";
    
    let _LDbitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DHSIZECURSOR) -> bmp in
    let _GETbitmapSize bmp -> [bw bh] in
    let _CRcursor themestr.EDT_channel bmp (bw / 2) (bh / 2) 0x000000 0xffffff -> cursor in
      set themestr.EDT_cursorSize = cursor;
    
    set themestr.EDT_abmpValUp = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTBTNVALUP);
    set themestr.EDT_abmpValDown = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTBTNVALDOWN);
    
    set themestr.EDT_abmpFrameFold = _LDalphaBitmap themestr.EDT_channel _checkpack (strcat sG2DDEFAULTRESOURCESPATH sG2DDEFAULTCHKFRAMEFOLD);    
    set themestr.EDT_iFrameFontColor = iG2DDEFAULTFRAMEFONTCOLOR;
    set themestr.EDT_sFrameFontName = "Arial";
    set themestr.EDT_iFrameFontSize = 9;
    set themestr.EDT_iFrameBarColor = iG2DDEFAULTBACKGROUNDCOLOR;
    set themestr.EDT_iFrameBarHeight = 18;

    set themestr.EDT_fontToolTip = _CRfont themestr.EDT_channel 8 0 FF_PIXEL "Arial";
    set themestr.EDT_fontModuleEditor = _CRfont themestr.EDT_channel 9 0 FF_PIXEL "Arial";
    set themestr.EDT_iModuleEditorBg = iG2DDEFAULTMODULEEDITORBGCOLOR;
    set themestr.EDT_iModuleEditorDot = iG2DDEFAULTMODULEEDITORDOTCOLOR;
    set themestr.EDT_iModuleEditorBoxOff = iG2DDEFAULTMODULEEDITORBOXOFFCOLOR;
    set themestr.EDT_iModuleEditorBoxOn = iG2DDEFAULTMODULEEDITORBOXONCOLOR;
    set themestr.EDT_iModuleEditorBoxBorderOff = iG2DDEFAULTMODULEEDITORBOXBORDEROFFCOLOR;
    set themestr.EDT_iModuleEditorBoxBorderOn = iG2DDEFAULTMODULEEDITORBOXBORDERONCOLOR;
    
    set themestr.EDT_iModuleEditorBoxTextOff = iG2DDEFAULTMODULEEDITORBOXTEXTOFFCOLOR;
    set themestr.EDT_iModuleEditorBoxTextOn = iG2DDEFAULTMODULEEDITORBOXTEXTONCOLOR;
    set themestr.EDT_iModuleEditorLinkOff = iG2DDEFAULTMODULEEDITORLINKOFFCOLOR;
    set themestr.EDT_iModuleEditorLinkOn = iG2DDEFAULTMODULEEDITORLINKONCOLOR;
    set themestr.EDT_iModuleEditorRLinkSize = iG2DDEFAULTMODULEEDITORROUNDLINKSIZE;
    set themestr.EDT_iModuleEditorBorderWidth = iG2DDEFAULTMODULEEDITORBORDERWIDTH;
    
    
    _SETdefaultFont _CRfont themestr.EDT_channel 15 0 0 "Microsoft San Serif";
    
    themestr;
  );
}


setEdColorMapResources(themestr, cmap, mapcross, btnpicker, curpicker){
if cmap == nil then nil else
  (
    set themestr.EDT_sColorMap = cmap;
  );
  
  if mapcross == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpColorMapCross;
    set themestr.EDT_abmpColorMapCross = _LDalphaBitmap themestr.EDT_channel _checkpack mapcross;
  );
  
  if btnpicker == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpColorMapPickerBtn;
    set themestr.EDT_abmpColorMapPickerBtn = _LDalphaBitmap themestr.EDT_channel _checkpack btnpicker;
  );
  
  if curpicker == nil then nil else
  (
    _DScursor themestr.EDT_cursorColorPicker;
    let _LDbitmap themestr.EDT_channel _checkpack curpicker -> bmp in
    let _GETbitmapSize bmp -> [bw bh] in
    let _CRcursor themestr.EDT_channel bmp (bw / 2) (bh / 2) 0x000000 0xffffff -> cursor in
      set themestr.EDT_cursorColorPicker = cursor;
  );  
  0;
}


setEdToolBarResources(themestr, backcolor){
if backcolor == nil then nil else
  (
    set themestr.EDT_iToolBarColor = backcolor;
  );
  0;
}


setEdTabResources(themestr, backcolor, tabcheck, tabclose, tableft, tabright, fontname, fontsize, fontcolor){
if backcolor == nil then nil else
  (
    set themestr.EDT_iTabBarColor = backcolor;
  );
  
  if tabcheck == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpTabCheck;
    set themestr.EDT_abmpTabCheck = _LDalphaBitmap themestr.EDT_channel _checkpack tabcheck;
  );
  
  if tabclose == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpTabClose;
    set themestr.EDT_abmpTabClose = _LDalphaBitmap themestr.EDT_channel _checkpack tabclose;
  );
  
  if tableft == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpTabLeft;
    set themestr.EDT_abmpTabLeft = _LDalphaBitmap themestr.EDT_channel _checkpack tableft;
  );
  
  if tabright == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpTabRight;
    set themestr.EDT_abmpTabRight = _LDalphaBitmap themestr.EDT_channel _checkpack tabright;
  );
  
  if (fontname == nil) || (fontsize == nil) then nil else
  (
    _DSfont themestr.EDT_fontTab;
    set themestr.EDT_fontTab = _CRfont themestr.EDT_channel fontsize 0 FF_PIXEL fontname;
  );
  
  if fontcolor == nil then nil else
  (
    set themestr.EDT_iTabFontColor = fontcolor;
  );  
  0;
}


setEdFloatResources(themestr, upbtn, downbtn, cursize){
if upbtn == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpValUp;
    set themestr.EDT_abmpValUp = _LDalphaBitmap themestr.EDT_channel _checkpack upbtn;
  );
  
  if downbtn == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpValDown;
    set themestr.EDT_abmpValDown = _LDalphaBitmap themestr.EDT_channel _checkpack downbtn;
  );
  
  if cursize == nil then nil else
  (
    _DScursor themestr.EDT_cursorSize;
    let _LDbitmap themestr.EDT_channel _checkpack cursize -> bmp in
    let _GETbitmapSize bmp -> [bw bh] in
    let _CRcursor themestr.EDT_channel bmp (bw / 2) (bh / 2) 0x000000 0xffffff -> cursor in
      set themestr.EDT_cursorSize = cursor;
  );
  0;
}
  

setEdFrameResources(themestr, backcolor, foldbtn, fontname, fontsize, fontcolor, barheight){
if backcolor == nil then nil else
  (
    set themestr.EDT_iFrameBarColor = backcolor;
  );
  
  if foldbtn == nil then nil else
  (
    _DSalphaBitmap themestr.EDT_abmpFrameFold;
    set themestr.EDT_abmpFrameFold = _LDalphaBitmap themestr.EDT_channel _checkpack foldbtn;
  );
  
  if (fontname == nil) then nil else
  (
    set themestr.EDT_sFrameFontName = fontname;
  );
  
  if (fontsize == nil) then nil else
  (
    set themestr.EDT_iFrameFontSize = fontsize;
  );  
  
  if fontcolor == nil then nil else
  (
    set themestr.EDT_iFrameFontColor = fontcolor;
  );
  
  if barheight == nil then nil else
  (
    set themestr.EDT_iFrameBarHeight = barheight;
  );
  0;
}


addEdThemeResource(themestr, resname, path){
if (resname == nil) || (path == nil) then nil else
  let _LDalphaBitmap themestr.EDT_channel _checkpack path -> abmp in
    set themestr.EDT_lAlphaResources = [resname abmp]::themestr.EDT_lAlphaResources;
  0;
}


delEdThemeResource(themestr, resname){
let switchstr themestr.EDT_lAlphaResources resname -> abmp in
    _DSalphaBitmap abmp;
  
  set themestr.EDT_lAlphaResources = G2DremoveEdSidFromList themestr.EDT_lAlphaResources resname;
  0;
}


getEdThemeResource(themestr, resname){
switchstr themestr.EDT_lAlphaResources resname;
}


delEdTheme(themestr){
let sizelist themestr.EDT_lAlphaResources -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list themestr.EDT_lAlphaResources i -> [_ abmp] in
      _DSalphaBitmap abmp;
      
    set i = i + 1;
  );
  
  set themestr.EDT_lAlphaResources = nil;
  
  _DScursor themestr.EDT_cursorColorPicker;
  set themestr.EDT_cursorColorPicker = nil;
  
  _DSalphaBitmap themestr.EDT_abmpColorMapCross;
  set themestr.EDT_abmpColorMapCross = nil;
  
  _DSalphaBitmap themestr.EDT_abmpColorMapPickerBtn;
  set themestr.EDT_abmpColorMapPickerBtn = nil;
  
  _DScursor themestr.EDT_cursorSize;
  set themestr.EDT_cursorSize = nil;  
  
  _DSfont themestr.EDT_fontTab;
  set themestr.EDT_fontTab = nil;
  
  _DSalphaBitmap themestr.EDT_abmpTabCheck;
  set themestr.EDT_abmpTabCheck = nil;
  
  _DSalphaBitmap themestr.EDT_abmpTabClose;
  set themestr.EDT_abmpTabClose = nil;
  
  _DSalphaBitmap themestr.EDT_abmpTabLeft;
  set themestr.EDT_abmpTabLeft = nil;
  
  _DSalphaBitmap themestr.EDT_abmpTabRight;
  set themestr.EDT_abmpTabRight = nil;
  
  _DSalphaBitmap themestr.EDT_abmpValUp;
  set themestr.EDT_abmpValUp = nil;
  
  _DSalphaBitmap themestr.EDT_abmpValDown;
  set themestr.EDT_abmpValDown = nil;            
  
  _DSalphaBitmap themestr.EDT_abmpFrameFold;
  set themestr.EDT_abmpFrameFold = nil;
  
  _DSfont themestr.EDT_fontModuleEditor;
  set themestr.EDT_fontModuleEditor = nil;
  
  _DSfont themestr.EDT_fontToolTip;
  set themestr.EDT_fontToolTip = nil;
  0;
}


/* ********************************************************************************************* /
  Tabs
/ ********************************************************************************************* */

resetEdTabPosition(tabbarstr){
set tabbarstr.ETABBAR_iCurrentLpos = 0;
  let sizelist tabbarstr.ETABBAR_lTab -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tabbarstr.ETABBAR_lTab i -> item in
    let _CONVERTcompCheckToObjNode item.ETAB_chk -> node in
    let _GETobjNodePositionSizeInFatherRef node -> [_ _ nw nh] in
    (
      _CHANGEobjNodeCoordinates node [tabbarstr.ETABBAR_iCurrentLpos 0] 0;
      set tabbarstr.ETABBAR_iCurrentLpos = tabbarstr.ETABBAR_iCurrentLpos + nw;
    );
    
    set i = i + 1;
  );
  0;
}


getEdTabsLength(tabbarstr, pos){
let sizelist tabbarstr.ETABBAR_lTab -> size in
  let 0 -> width in
  let if !pos then 0 else pos -> i in
  (
    while i < size do
    (
      let nth_list tabbarstr.ETABBAR_lTab i -> elem in
      let _GETobjNodePositionSizeInFatherRef (_CONVERTcompCheckToObjNode elem.ETAB_chk) -> [_ _ w h] in
        set width = width + w;
      
      set i = i + 1;
    );
    width;
  );
}


getEdLastVisibleTabs(tabbarstr){
let sizelist tabbarstr.ETABBAR_lTab -> size in
  let _GETcontainerPositionSize tabbarstr.ETABBAR_contScroll -> [_ _ cw _] in  
  let tabbarstr.ETABBAR_size -> [tw _] in
  let (tw -cw) -> width in
  let 0 -> ww in
  let tabbarstr.ETABBAR_iScrollPos -> i in
  (
    while (i < size) && (ww < width) do
    (
      let nth_list tabbarstr.ETABBAR_lTab i -> elem in
      let _GETobjNodePositionSizeInFatherRef (_CONVERTcompCheckToObjNode elem.ETAB_chk) -> [_ _ w h] in
        set ww = ww + w;

      set i = i + 1;
    );
    i - 1;
  );
}


getEdBestTabsByLength(tabbarstr, w, pos){
if !pos then 0 else
  let getEdTabsLength tabbarstr pos -> width in
  let sizelist tabbarstr.ETABBAR_lTab -> size in
  (
    while pos >= 0 && (width < w) do
    (
      set width = getEdTabsLength tabbarstr pos - 1;
      set pos = pos - 1;
    );
    pos;
  );
}


activateEdTabBarScroll(tabbarstr){
let getEdTabsLength tabbarstr 0 -> width in
  let tabbarstr.ETABBAR_size -> [w _] in
  if width < w then
  // hide buttons
  (
    _SHOWcontainer tabbarstr.ETABBAR_contScroll CONTAINER_HIDDEN;
    let _GETobjNodePositionSizeInFatherRef tabbarstr.ETABBAR_node -> [nx ny _ _] in
      _CHANGEobjNodeCoordinates tabbarstr.ETABBAR_node [0 ny] 1;    
    0;
  )
  else
  // show scroll buttons
  (
    _SHOWcontainer tabbarstr.ETABBAR_contScroll CONTAINER_UNHIDDEN;
    0;
  );
  0;
}


cbEdTabClick(cmpchk, param, x, y, btn, mask){
0;
}
  

cbEdTabUnClick(cmpchk, param, x, y, btn, mask){
let param -> [tabbarstr tabstr] in
  (
    if (_GETcompCheckState cmpchk) == CHK_UNCHECKED then
    (
      _SETcompCheckState cmpchk CHK_CHECKED;
      0;
    )
    else
    (
      focusEdTab tabbarstr tabstr;
      0;
    );
    
    _PAINTcontainer tabbarstr.ETABBAR_cont;
  );
  0;
}


cbEdTabResize(cmpchk, p, w, h){
0;
}


cbEdCloseTabClick(cmproll, param, x, y, btn, mask){
let param -> [tabbarstr tabstr] in
  (
    exec tabstr.ETAB_cbClosed with [tabstr];
    dsEdTab tabbarstr tabstr;
  );
  0;
}


setEdTabCbClose(tabstr, cbfun){
set tabstr.ETAB_cbClosed = cbfun;
  0;
}


changeEdTabCheck(tabbarstr, tabstr){
let _GETobjNodePositionSizeInFatherRef (_CONVERTcompCheckToObjNode tabstr.ETAB_chk) -> [px py _ _] in
  (
    _DScompCheck tabstr.ETAB_chk;
    set tabstr.ETAB_chk = nil;
    _DSalphaBitmap tabstr.ETAB_abmpTab;
    set tabstr.ETAB_abmpTab = nil;  
    _DScompRollOver tabstr.ETAB_closeBtn;
    set tabstr.ETAB_closeBtn = nil;
    
    let _GETalphaBitmapSize tabbarstr.ETABBAR_theme.EDT_abmpTabCheck -> [taw tah] in
    let _GETalphaBitmapSize tabbarstr.ETABBAR_theme.EDT_abmpTabClose -> [tcw tch] in
    let [tcw (tch / 5)] -> [tcw tch] in
    let [(taw / 2) (tah / 5)] -> [tw th] in
    let (G2DgetStrWidth tabbarstr.ETABBAR_theme.EDT_fontTab tabstr.ETAB_sName) + (tabbarstr.ETABBAR_iMargin * 2) -> tabw in
    let tabbarstr.ETABBAR_theme.EDT_iTabFontColor -> c1 in  
    let G2DbBmp_stretchButtonText
                tabstr.ETAB_channel
                [tabstr.ETAB_sName tabbarstr.ETABBAR_theme.EDT_fontTab]
                [tabw th]
                [
                  nil
                  (c1::c1::c1::c1::0xdddddd::nil)::(c1::c1::c1::c1::0xdddddd::nil)::nil
                ]
                [10 10 12 2]
                [5 2]
                tabbarstr.ETABBAR_theme.EDT_abmpTabCheck
                if !tabstr.ETAB_bState then 0 else tcw + 5
    -> img in
    let _GETalphaBitmapSize img -> [nw nh] in
    (
      set tabstr.ETAB_abmpTab = img;
      set tabstr.ETAB_chk = _CRcompCheck tabstr.ETAB_channel tabbarstr.ETABBAR_cont tabbarstr.ETABBAR_node [px py] OBJ_ENABLE|OBJ_VISIBLE|ROL_DISABLE|ROL_MASK OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_MOVE img;
      
      if !tabstr.ETAB_bState then nil else
      (
        set tabstr.ETAB_closeBtn = _CRcompRollOver tabstr.ETAB_channel tabbarstr.ETABBAR_cont (_CONVERTcompCheckToObjNode tabstr.ETAB_chk) [((nw / 2) - (tcw + 5)) (((nh / 5) - tch) / 2)] OBJ_ENABLE|OBJ_VISIBLE|ROL_DISABLE|ROL_MASK nil tabbarstr.ETABBAR_theme.EDT_abmpTabClose;
        _CBcompRollOverUnClick tabstr.ETAB_closeBtn @cbEdCloseTabClick [tabbarstr tabstr];
      );
      
      _CBcompCheckClick tabstr.ETAB_chk @cbEdTabClick [tabbarstr tabstr];
      _CBcompCheckUnClick tabstr.ETAB_chk @cbEdTabUnClick [tabbarstr tabstr];
      _CBcompCheckResize tabstr.ETAB_chk @cbEdTabResize [tabbarstr tabstr];
    );
  );
  0;
}


focusEdTab(tabbarstr, tabstr){
let sizelist tabbarstr.ETABBAR_lTab -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tabbarstr.ETABBAR_lTab i -> item in
    if item == tabstr then
    (
      set item.ETAB_bState = 1;
      if item.ETAB_modeFlag & ETAB_CLOSEBTN then
        changeEdTabCheck tabbarstr item
      else nil;
      
      let tabbarstr.ETABBAR_size -> [w _] in
      let _GETcontainerPositionSize tabbarstr.ETABBAR_contScroll -> [_ _ cw _] in  
      let getEdLastVisibleTabs tabbarstr -> lastvisibletab in
      let getEdBestTabsByLength tabbarstr (w -cw) i -> pos in
      if (i >= tabbarstr.ETABBAR_iScrollPos) && (i < lastvisibletab) then nil else
      (
        set tabbarstr.ETABBAR_iScrollPos = if i == (size - 1) then pos + 1 else pos;
        
        let nth_list tabbarstr.ETABBAR_lTab tabbarstr.ETABBAR_iScrollPos -> sctabstr in
        let _GETobjNodePositionSizeInFatherRef (_CONVERTcompCheckToObjNode sctabstr.ETAB_chk) -> [cx _ _ _] in
        let _GETobjNodePositionSizeInFatherRef tabbarstr.ETABBAR_node -> [nx ny _ _] in
          _CHANGEobjNodeCoordinates tabbarstr.ETABBAR_node [-cx ny] 1;
      );
      
      _SETcompCheckState item.ETAB_chk CHK_CHECKED;
      exec item.ETAB_cbFocused with [item];
      setEdWindowVisible item.ETAB_win 1;
      _SETfocus item.ETAB_win.EDW_win;
      set tabbarstr.ETABBAR_currentTab = item;
      0;
    )
    else
    (
      if !item.ETAB_bState then nil else
        set tabbarstr.ETABBAR_lastTab = item;
      
      set item.ETAB_bState = 0;
      if item.ETAB_modeFlag & ETAB_CLOSEBTN then
        changeEdTabCheck tabbarstr item
      else nil;
      
      _SETcompCheckState item.ETAB_chk CHK_UNCHECKED;
      setEdWindowVisible item.ETAB_win 0;  
      0;
    );
    
    set i = i + 1;
  );
  resetEdTabPosition tabbarstr;
  activateEdTabBarScroll tabbarstr;
  0;
}


dsEdTab(tabbarstr, tabstr){
set tabbarstr.ETABBAR_lTab = G2DremoveFromList tabbarstr.ETABBAR_lTab tabstr;
  
  dsEdWindow tabstr.ETAB_win;
  set tabstr.ETAB_win = nil;
  
  _DScompCheck tabstr.ETAB_chk;
  set tabstr.ETAB_chk = nil;
  _DScompRollOver tabstr.ETAB_closeBtn;
  set tabstr.ETAB_closeBtn = nil;
  _DSalphaBitmap tabstr.ETAB_abmpTab;
  set tabstr.ETAB_abmpTab = nil;
  
  resetEdTabPosition tabbarstr;
  activateEdTabBarScroll tabbarstr;
  
  // select lasttab or last inserted
  if tabbarstr.ETABBAR_currentTab != tabstr then
    nil
  else if tabbarstr.ETABBAR_lastTab.ETAB_chk == nil then
    let sizelist tabbarstr.ETABBAR_lTab -> size in
    focusEdTab tabbarstr (nth_list tabbarstr.ETABBAR_lTab (size -1))
  else
    focusEdTab tabbarstr tabbarstr.ETABBAR_lastTab;
  
  _PAINTcontainer tabbarstr.ETABBAR_cont;
  0;
}


crEdTab(tabbarstr, name, mode, state){
let if mode == nil then 0 else mode -> mode in
  let mkEdTab [tabbarstr.ETABBAR_channel tabbarstr nil name nil nil nil nil nil nil nil nil nil] -> tabstr in
  let _GETalphaBitmapSize tabbarstr.ETABBAR_theme.EDT_abmpTabCheck -> [taw tah] in
  let [(taw / 2) (tah / 5)] -> [tw th] in
  let (G2DgetStrWidth tabbarstr.ETABBAR_theme.EDT_fontTab name) + (tabbarstr.ETABBAR_iMargin * 2) -> tabw in
  let tabbarstr.ETABBAR_theme.EDT_iTabFontColor -> c1 in
  let G2DbBmp_stretchButtonText
        tabstr.ETAB_channel
        [tabstr.ETAB_sName tabbarstr.ETABBAR_theme.EDT_fontTab]
        [tabw th]
        [
          nil
          (c1::c1::c1::c1::0xdddddd::nil)::(c1::c1::c1::c1::0xdddddd::nil)::nil
        ]
        [10 10 12 2]
        [5 2]
        tabbarstr.ETABBAR_theme.EDT_abmpTabCheck
        0
  -> img in
  let _GETalphaBitmapSize img -> [nw nh] in
  (
    set tabstr.ETAB_abmpTab = img;
    
    set tabstr.ETAB_bState = (if tabbarstr.ETABBAR_lTab == nil then 1 else state);
    set tabstr.ETAB_modeFlag = mode;
    
    let _GETwindowPositionSize tabbarstr.ETABBAR_targetWin.EDW_win -> [_ _ ww wh] in
    let getEdWindowToolBarSize tabbarstr.ETABBAR_targetWin -> [tww twh] in
    let [(ww - tww) (wh - twh)] -> [ww wh] in
    // hack if width or heigth is negative on creation
    let [(if ww <= 0 then 100 else ww) (if wh <= 0 then 100 else wh)] -> [ww wh] in
      set tabstr.ETAB_win = crEdWindow tabstr.ETAB_channel tabbarstr.ETABBAR_targetWin tww twh ww wh WN_CHILDINSIDE|WN_NOBORDER|WN_HIDDEN EDWIN_RESIZE_MW|EDWIN_RESIZE_MH EDWIN_TAB "";
    
    set tabbarstr.ETABBAR_lTab = G2Dlcat tabbarstr.ETABBAR_lTab tabstr::nil;
    
    set tabstr.ETAB_chk = _CRcompCheck tabstr.ETAB_channel tabbarstr.ETABBAR_cont tabbarstr.ETABBAR_node [tabbarstr.ETABBAR_iCurrentLpos 0] OBJ_ENABLE|OBJ_VISIBLE|ROL_DISABLE|ROL_MASK OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_MOVE img;
    set tabbarstr.ETABBAR_iCurrentLpos = tabbarstr.ETABBAR_iCurrentLpos + (nw / 2);
    
    _CBcompCheckClick tabstr.ETAB_chk @cbEdTabClick [tabbarstr tabstr];
    _CBcompCheckUnClick tabstr.ETAB_chk @cbEdTabUnClick [tabbarstr tabstr];
    _CBcompCheckResize tabstr.ETAB_chk @cbEdTabResize [tabbarstr tabstr];
    
    if !tabstr.ETAB_bState then
    (
      activateEdTabBarScroll tabbarstr;
      0;
    )
    else
    (
      focusEdTab tabbarstr tabstr;
      0;
    );
    
    _PAINTcontainer tabbarstr.ETABBAR_cont;
    
    tabstr;
  );
}


getEdTabWindow(tabstr){
tabstr.ETAB_win;
}



setEdTabCbFocused(tabstr, cbfun){
set tabstr.ETAB_cbFocused = cbfun;
}


resizeEdTabBar(tabbarstr, w, h){
let tabbarstr.ETABBAR_pos -> [x y] in
    _SIZEcontainer tabbarstr.ETABBAR_cont x y (w - tabbarstr.ETABBAR_rightPos) h;
  
  set tabbarstr.ETABBAR_size = [(w - tabbarstr.ETABBAR_rightPos) h];
  
  let _GETcontainerPositionSize tabbarstr.ETABBAR_contScroll -> [cx cy cw ch] in
  _SIZEcontainer tabbarstr.ETABBAR_contScroll (w - tabbarstr.ETABBAR_rightPos - cw) cy cw ch;  
  activateEdTabBarScroll tabbarstr;
  
  focusEdTab tabbarstr tabbarstr.ETABBAR_currentTab;
  _PAINTcontainer tabbarstr.ETABBAR_cont;
  0;
}


dsEdTabBar(tabbarstr){
let sizelist tabbarstr.ETABBAR_lTab -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tabbarstr.ETABBAR_lTab i -> tabstr in
      dsEdTab tabbarstr tabstr;
    set i = i + 1;
  );
  
  set tabbarstr.ETABBAR_lTab = nil;
  
  _DScompRollOver tabbarstr.ETABBAR_btnScrollL;
  set tabbarstr.ETABBAR_btnScrollL = nil;
  _DScompRollOver tabbarstr.ETABBAR_btnScrollR;
  set tabbarstr.ETABBAR_btnScrollR = nil;
  _DScontainer tabbarstr.ETABBAR_contScroll;
  set tabbarstr.ETABBAR_contScroll = nil;
  
  _DScontainer tabbarstr.ETABBAR_cont;
  set tabbarstr.ETABBAR_cont = nil;
  0;
}


cbEdTabBarScrollLeft(cmpbtn, tabbarstr, x, y, btn, mask){
set tabbarstr.ETABBAR_iScrollPos = if (tabbarstr.ETABBAR_iScrollPos - 1) <=0 then 0 else tabbarstr.ETABBAR_iScrollPos - 1;
  let nth_list tabbarstr.ETABBAR_lTab tabbarstr.ETABBAR_iScrollPos -> tabstr in
  let _GETobjNodePositionSizeInFatherRef (_CONVERTcompCheckToObjNode tabstr.ETAB_chk) -> [cx _ w h] in
  let _GETobjNodePositionSizeInFatherRef tabbarstr.ETABBAR_node -> [nx ny _ _] in
    _CHANGEobjNodeCoordinates tabbarstr.ETABBAR_node [-cx ny] 1;
  0;
}


cbEdTabBarScrollRight(cmpbtn, tabbarstr, x, y, btn, mask){
let getEdTabsLength tabbarstr tabbarstr.ETABBAR_iScrollPos -> width in
  let tabbarstr.ETABBAR_size -> [w _] in
  let _GETcontainerPositionSize tabbarstr.ETABBAR_contScroll -> [_ _ cw _] in  
  if width <= (w - cw) then nil else
  (
    set tabbarstr.ETABBAR_iScrollPos = if tabbarstr.ETABBAR_iScrollPos >= ((sizelist tabbarstr.ETABBAR_lTab) - 1) then ((sizelist tabbarstr.ETABBAR_lTab) - 1) else tabbarstr.ETABBAR_iScrollPos + 1;
    let nth_list tabbarstr.ETABBAR_lTab tabbarstr.ETABBAR_iScrollPos -> tabstr in
    let _GETobjNodePositionSizeInFatherRef (_CONVERTcompCheckToObjNode tabstr.ETAB_chk) -> [cx _ w h] in
    let _GETobjNodePositionSizeInFatherRef tabbarstr.ETABBAR_node -> [nx ny _ _] in
      _CHANGEobjNodeCoordinates tabbarstr.ETABBAR_node [-cx ny] 1;
  );
  0;
}


makeEdTabBarScroll(tabbarstr){
let _GETalphaBitmapSize tabbarstr.ETABBAR_theme.EDT_abmpTabLeft -> [blw blh] in
  let _GETalphaBitmapSize tabbarstr.ETABBAR_theme.EDT_abmpTabRight -> [brw brh] in
  let blh / 5 -> blh in
  let brh / 5 -> brh in  
  let tabbarstr.ETABBAR_size -> [w h] in
  (
    set tabbarstr.ETABBAR_contScroll = _CRcontainerFromObjCont tabbarstr.ETABBAR_channel tabbarstr.ETABBAR_cont (w - (blw + brw)) 0 (blw + brw) blh CO_HIDE|CO_CHILDINSIDE|CO_NOBORDER|CO_NOCAPTION tabbarstr.ETABBAR_theme.EDT_iTabBarColor "";
    set tabbarstr.ETABBAR_btnScrollL = _CRcompRollOver tabbarstr.ETABBAR_channel tabbarstr.ETABBAR_contScroll nil [0 0] OBJ_ENABLE|OBJ_VISIBLE|ROL_MASK|ROL_DISABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK tabbarstr.ETABBAR_theme.EDT_abmpTabLeft;
    set tabbarstr.ETABBAR_btnScrollR = _CRcompRollOver tabbarstr.ETABBAR_channel tabbarstr.ETABBAR_contScroll nil [blw 0] OBJ_ENABLE|OBJ_VISIBLE|ROL_MASK|ROL_DISABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK tabbarstr.ETABBAR_theme.EDT_abmpTabRight;
    _CBcompRollOverUnClick tabbarstr.ETABBAR_btnScrollL @cbEdTabBarScrollLeft tabbarstr;
    _CBcompRollOverUnClick tabbarstr.ETABBAR_btnScrollR @cbEdTabBarScrollRight tabbarstr;
    
    _PAINTcontainer tabbarstr.ETABBAR_contScroll;
    _TOPcontainer tabbarstr.ETABBAR_contScroll;
  );
  0;
}


crEdTabBarFromToolBar(tbstr, targetstr, x, y, w, h, margin, themestr){
let if themestr == nil then (if EdDefaultTheme == nil then (set EdDefaultTheme = makeEdThemeResources tbstr.ETB_channel) else EdDefaultTheme) else themestr -> themestr in

  let tbstr.ETB_size -> [tbw tbh] in
  let mkEdTabBar [tbstr.ETB_channel nil nil targetstr tbh [(tbstr.ETB_iCurrentLpos + x) y] [w h] (tbw - (tbstr.ETB_iCurrentLpos + x + w)) margin 0 nil themestr nil nil nil nil nil 0] -> tabbarstr in  
  (
    set tbstr.ETB_tabBar = tabbarstr;
    set tabbarstr.ETABBAR_cont = _CRcontainerFromObjCont tabbarstr.ETABBAR_channel tbstr.ETB_cont (tbstr.ETB_iCurrentLpos + x) y w h CO_CHILDINSIDE|CO_NOBORDER|CO_NOCAPTION themestr.EDT_iTabBarColor "";
    set tabbarstr.ETABBAR_node = G2DcreateNode tabbarstr.ETABBAR_cont nil [0 0] w h nil 0xffffff 0 nil nil;
    
    set tbstr.ETB_iCurrentLpos = tbstr.ETB_iCurrentLpos + x + w;
    
    makeEdTabBarScroll tabbarstr;
    
    _PAINTcontainer tabbarstr.ETABBAR_cont;
    tabbarstr;
  );
}


/* ********************************************************************************************* /
  ToolBar
/ ********************************************************************************************* */
cbEdToolBarToolTipHide(node, t, bubble){
let switch t.ETB_lTooltip node -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set t.ETB_lTooltip = G2DremoveEdIdxFromList t.ETB_lTooltip node;
  );
  0;
}


cbEdToolBarToolTipShow(node, t, bubble, dx, dy){
let switch t.ETB_lTooltip node -> [tpcont tptext] in
  if tpcont == nil then nil else
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set t.ETB_lTooltip = G2DremoveEdIdxFromList t.ETB_lTooltip node;
  );
  
  let G2DgetStringSize t.ETB_fontTooltip bubble -> [w h] in  
  let _GETscreenSize -> [sw sh] in
  let sh - 40 -> sh in
  let _GETscreenPos -> [sx sy] in
  let [16 16] -> [xdecal ydecal] in
  let if (sx + w + 4 + xdecal) > sw then (sw - (w + 4) - xdecal) else sx + xdecal -> x in
  let if (sy + h + 4 + ydecal) > sh then (sh - (h + 4) - ydecal) else sy + ydecal -> y in
  let (_CRcontainerFromObjWin t.ETB_channel t.ETB_win x y w+4 h+4 CO_NOCAPTION 0xffffff nil) -> tpcont in
  let _CRcompText t.ETB_channel tpcont nil [2 2] CT_LABEL|CT_CENTER|OBJ_VISIBLE nil w h bubble t.ETB_fontTooltip [0 nil nil nil] nil nil nil -> tptext in
  (
    set t.ETB_lTooltip = [node [tpcont tptext]]::t.ETB_lTooltip;
    _PAINTcontainer tpcont;
  );
  0;
}
  

cbEdToolBarTextResize(ctext, param, w, h){
0;
}


setEdToolBarText(t, cmptxt, val, txtcolor){
let switch t.ETB_lText cmptxt -> font in
  let _GETstringSize font val -> [w h] in
  (
    _SETcompText cmptxt val font [txtcolor 0 0 0] 0;
    _SIZEobjNode _CONVERTcompTextToObjNode cmptxt w h 0;
    
    let _GETcontainerPositionSize t.ETB_cont -> [_ _ cw ch] in
    (
      set t.ETB_iCurrentLpos = 0;
      set t.ETB_iCurrentRpos = cw;
      set t.ETB_iCurrentTpos = 0;
      set t.ETB_iCurrentBpos = ch;
    );
    
    let sizelist t.ETB_lControl -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list t.ETB_lControl i -> [node align] in
      let _GETobjNodePositionSizeInContainerRef node -> [_ _ nw nh] in
      let
          if align == ETB_ALIGN_RIGHT then
            [(set t.ETB_iCurrentRpos = t.ETB_iCurrentRpos - t.ETB_iHmargin - nw) t.ETB_iVmargin]
          else if align == ETB_ALIGN_TOP then
            [t.ETB_iHmargin ((set t.ETB_iCurrentTpos = t.ETB_iCurrentTpos + t.ETB_iVmargin + nh) - nh)]
          else if align == ETB_ALIGN_BOTTOM then
            [t.ETB_iHmargin (set t.ETB_iCurrentBpos = t.ETB_iCurrentBpos - t.ETB_iVmargin - nh)]
          else
            [((set t.ETB_iCurrentLpos = t.ETB_iCurrentLpos + t.ETB_iHmargin + nw) - nw) t.ETB_iVmargin]
      -> npos in
        _CHANGEobjNodeCoordinates node npos 0;
      
      set i = i + 1;
    );
    _PAINTcontainer t.ETB_cont;
  );
  0;
}


crEdToolBarText(t, txt, fontname, fontsize, fontflag, txtcolor, flags, align){
let _CRfont t.ETB_channel fontsize 0 (if fontflag == nil then 0 else fontflag) fontname -> font in
  let if flags == nil then OBJ_ENABLE|OBJ_VISIBLE|CT_LEFT|CT_LABEL else flags|OBJ_ENABLE|OBJ_VISIBLE -> flags in
  let _GETstringSize font txt -> [w h] in
  let
      if align == ETB_ALIGN_RIGHT then
        [(set t.ETB_iCurrentRpos = t.ETB_iCurrentRpos - t.ETB_iHmargin - w) t.ETB_iVmargin]
      else if align == ETB_ALIGN_TOP then
        [t.ETB_iHmargin ((set t.ETB_iCurrentTpos = t.ETB_iCurrentTpos + t.ETB_iVmargin + h) - h)]
      else if align == ETB_ALIGN_BOTTOM then
        [t.ETB_iHmargin (set t.ETB_iCurrentBpos = t.ETB_iCurrentBpos - t.ETB_iVmargin - h)]
      else
        [((set t.ETB_iCurrentLpos = t.ETB_iCurrentLpos + t.ETB_iHmargin + w) - w) t.ETB_iVmargin]
  -> [x y] in
  let _CRcompText t.ETB_channel t.ETB_cont nil [x y] flags OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK w h txt font [txtcolor 0 0 0] nil nil nil -> text in
  (
    _CBcompTextResize text @cbEdToolBarTextResize [t nil] nil nil nil nil;
    set t.ETB_lText = [text font]::t.ETB_lText;
    set t.ETB_lControl = G2Dlcat t.ETB_lControl [(_CONVERTcompTextToObjNode text) align]::nil;
    text;
  );
}


cbEdToolBarCheckClick(check, param, x, y, btn, mask){
let param -> [t cbclick] in
  let _GETcompCheckState check -> state in
    exec cbclick with [t check btn mask state];
  0;
}


cbEdToolBarCheckIn(croll, param, x, y, mask){
0;
}


cbEdToolBarCheckOut(croll, param, x, y, mask){
0;
}


cbEdToolBarCheckResize(croll, param, w, h){
0;
}


setEdToolBarCheckState(t, chk, state){
_SETcompCheckState chk state;
  _PAINTcontainer t.ETB_cont;
  0;
}


setEdToolBarCheckEnable(t, chk, state){
let if state then OBJ_ENABLE else OBJ_DISABLE -> state in
    _CHANGEobjNodeFlags (_CONVERTcompCheckToObjNode chk) OBJ_VISIBLE|ROL_MASK|ROL_DISABLE|state 1;
  _PAINTcontainer t.ETB_cont;
  0;
}


setEdToolBarCheckCbClick(t, check, cbclick){
_CBcompCheckUnClick check @cbEdToolBarCheckClick [t cbclick];
  0;
}  


crEdToolBarCheck(t, abmp, align, bubble, cbclick){
let _GETalphaBitmapSize abmp -> [bw bh] in
  let [(bw / 2) (bh / 5)] -> [w h] in
  let
      if align == ETB_ALIGN_RIGHT then
        [(set t.ETB_iCurrentRpos = t.ETB_iCurrentRpos - t.ETB_iHmargin - w) t.ETB_iVmargin]
      else if align == ETB_ALIGN_TOP then
        [t.ETB_iHmargin ((set t.ETB_iCurrentTpos = t.ETB_iCurrentTpos + t.ETB_iVmargin + h) - h)]
      else if align == ETB_ALIGN_BOTTOM then
        [t.ETB_iHmargin (set t.ETB_iCurrentBpos = t.ETB_iCurrentBpos - t.ETB_iVmargin - h)]
      else
        [((set t.ETB_iCurrentLpos = t.ETB_iCurrentLpos + t.ETB_iHmargin + w) - w) t.ETB_iVmargin]
  -> [x y] in
  let _CRcompCheck t.ETB_channel t.ETB_cont nil [x y] OBJ_ENABLE|ROL_MASK|ROL_DISABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK abmp -> check in
  (
    _CRtoolTip _CONVERTcompCheckToObjNode check 150 bubble @cbEdToolBarToolTipShow t @cbEdToolBarToolTipHide t;
    _CBcompCheckUnClick check @cbEdToolBarCheckClick [t cbclick];
    _CBcompCheckCursorMoveIn check @cbEdToolBarCheckIn [t nil];
    _CBcompCheckCursorMoveOut check @cbEdToolBarCheckOut [t nil];
    _CBcompCheckResize check @cbEdToolBarCheckResize [t nil];
    set t.ETB_lCheck = check::t.ETB_lCheck;
    set t.ETB_lControl = G2Dlcat t.ETB_lControl [(_CONVERTcompCheckToObjNode check) align]::nil;
    check;
  );
}


setEdToolBarButtonEnable(t, btn, state){
let if state then OBJ_ENABLE else OBJ_DISABLE -> state in
    _CHANGEobjNodeFlags (_CONVERTcompRollOverToObjNode btn) OBJ_VISIBLE|ROL_MASK|ROL_DISABLE|state 1;
  _PAINTcontainer t.ETB_cont;
  0;
}


cbEdToolBarButtonClick(croll, param, x, y, btn, mask){
let param -> [t cbclick] in
    exec cbclick with [t croll btn mask];
  0;
}


cbEdToolBarButtonIn(croll, param, x, y, mask){
0;
}


cbEdToolBarButtonOut(croll, param, x, y, mask){
0;
}
  

cbEdToolBarButtonResize(croll, param, w, h){
0;
}
  

crEdToolBarButton(t, abmp, align, bubble, cbclick){
let _GETalphaBitmapSize abmp -> [bw bh] in
  let [bw (bh / 5)] -> [w h] in  
  let
      if align == ETB_ALIGN_RIGHT then
        [(set t.ETB_iCurrentRpos = t.ETB_iCurrentRpos - t.ETB_iHmargin - w) t.ETB_iVmargin]
      else if align == ETB_ALIGN_TOP then
        [t.ETB_iHmargin ((set t.ETB_iCurrentTpos = t.ETB_iCurrentTpos + t.ETB_iVmargin + h) - h)]
      else if align == ETB_ALIGN_BOTTOM then
        [t.ETB_iHmargin (set t.ETB_iCurrentBpos = t.ETB_iCurrentBpos - t.ETB_iVmargin - h)]
      else
        [((set t.ETB_iCurrentLpos = t.ETB_iCurrentLpos + t.ETB_iHmargin + w) - w) t.ETB_iVmargin]
  -> [x y] in
  let _CRcompRollOver t.ETB_channel t.ETB_cont nil [x y] OBJ_ENABLE|OBJ_VISIBLE|ROL_MASK|ROL_DISABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK abmp -> button in
  (
    _CRtoolTip _CONVERTcompRollOverToObjNode button 150 bubble @cbEdToolBarToolTipShow t @cbEdToolBarToolTipHide t;
    _CBcompRollOverUnClick button @cbEdToolBarButtonClick [t cbclick];
    _CBcompRollOverCursorMoveIn button @cbEdToolBarButtonIn [t nil];
    _CBcompRollOverCursorMoveOut button @cbEdToolBarButtonOut [t nil];
    _CBcompRollOverResize button @cbEdToolBarButtonResize [t nil];
    set t.ETB_lButton = button::t.ETB_lButton;
    set t.ETB_lControl = G2Dlcat t.ETB_lControl [(_CONVERTcompRollOverToObjNode button) align]::nil;
    button;
  );
}


cbEdToolBarBmpClick(bmp, p, x, y, btn, mask){
let p -> [t cbclick] in
    exec cbclick with [t btn mask 0];
  0;
}


cbEdToolBarBmpDbClick(bmp, p, x, y, btn, mask){
let p -> [t cbclick] in
    exec cbclick with [t btn mask 1];
  0;
}


crEdToolBarBitmap(t, abmp, align, bubble, cbclick){
let _GETalphaBitmapSize abmp -> [w h] in
  let
      if align == ETB_ALIGN_RIGHT then
        [(set t.ETB_iCurrentRpos = t.ETB_iCurrentRpos - t.ETB_iHmargin - w) t.ETB_iVmargin]
      else if align == ETB_ALIGN_TOP then
        [t.ETB_iHmargin ((set t.ETB_iCurrentTpos = t.ETB_iCurrentTpos + t.ETB_iVmargin + h) - h)]
      else if align == ETB_ALIGN_BOTTOM then
        [t.ETB_iHmargin (set t.ETB_iCurrentBpos = t.ETB_iCurrentBpos - t.ETB_iVmargin - h)]
      else
        [((set t.ETB_iCurrentLpos = t.ETB_iCurrentLpos + t.ETB_iHmargin + w) - w) t.ETB_iVmargin]
  -> [x y] in
  let _CRcompBitmap t.ETB_channel t.ETB_cont nil [x y] OBJ_ENABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK abmp 0 0 w h -> bmp in
  (
    _CRtoolTip _CONVERTcompBitmapToObjNode bmp 150 bubble @cbEdToolBarToolTipShow t @cbEdToolBarToolTipHide t;
    _CBcompBitmapClick bmp @cbEdToolBarBmpClick [t cbclick];
    _CBcompBitmapDblClick bmp @cbEdToolBarBmpDbClick [t cbclick];
    set t.ETB_lBmp = bmp::t.ETB_lBmp;
    set t.ETB_lControl = G2Dlcat t.ETB_lControl [(_CONVERTcompBitmapToObjNode bmp) align]::nil;
    bmp;
   );
}


dsEdToolBar(win, tbstr){
_DSwindow tbstr.ETB_win;
  _DScontainer tbstr.ETB_cont;
  
  set tbstr.ETB_win = nil;
  set tbstr.ETB_cont = nil;
  
  let sizelist tbstr.ETB_lButton -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tbstr.ETB_lButton i -> btn in
      _DScompRollOver btn;
    
    set i = i + 1;
  );
  
  let sizelist tbstr.ETB_lBmp -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tbstr.ETB_lBmp i -> bmp in
      _DScompBitmap bmp;
    
    set i = i + 1;
  );
  
  let sizelist tbstr.ETB_lCheck -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tbstr.ETB_lCheck i -> chk in
      _DScompCheck chk;
    
    set i = i + 1;
  );
  
  let sizelist tbstr.ETB_lText -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tbstr.ETB_lText i -> [txt font] in
    (
      _DScompText txt;
      _DSfont font;
    );
    
    set i = i + 1;
  );
  
  let sizelist tbstr.ETB_lTooltip -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list tbstr.ETB_lTooltip i -> [_ [cont text]] in
    (
      _DScompText text;
      _DScontainer cont;
    );
    
    set i = i + 1;
  );
  
  
  dsEdTabBar tbstr.ETB_tabBar;
  set tbstr.ETB_tabBar = nil;
  
  set tbstr.ETB_lControl = nil;
  
  _DSfont tbstr.ETB_fontTooltip;
  set tbstr.ETB_fontTooltip = nil; 
  0;
}


dsEdToolBarList(l){
let sizelist l -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list l i -> elt in
      dsEdToolBar nil elt;
    
    set i = i + 1;
  );
  0;
}


sizeEdToolBar(t, x, y, w, h){
_SIZEwindow t.ETB_win w h x y;
  _SIZEcontainer t.ETB_cont 0 0 w h;
  
  set t.ETB_iCurrentLpos = 0;
  set t.ETB_iCurrentRpos = w;
  set t.ETB_iCurrentTpos = 0;
  set t.ETB_iCurrentBpos = h;
  
  set t.ETB_size = [w h];
  
  let sizelist t.ETB_lControl   -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list t.ETB_lControl i -> [node align] in
    let _GETobjNodePositionSizeInContainerRef node -> [_ _ nw nh] in
    let
        if align == ETB_ALIGN_RIGHT then
          [(set t.ETB_iCurrentRpos = t.ETB_iCurrentRpos - t.ETB_iHmargin - nw) t.ETB_iVmargin]
        else if align == ETB_ALIGN_TOP then
          [t.ETB_iHmargin ((set t.ETB_iCurrentTpos = t.ETB_iCurrentTpos + t.ETB_iVmargin + nh) - nh)]
        else if align == ETB_ALIGN_BOTTOM then
          [t.ETB_iHmargin (set t.ETB_iCurrentBpos = t.ETB_iCurrentBpos - t.ETB_iVmargin - nh)]
        else
          [((set t.ETB_iCurrentLpos = t.ETB_iCurrentLpos + t.ETB_iHmargin + nw) - nw) t.ETB_iVmargin]
    -> npos in
      _CHANGEobjNodeCoordinates node npos 0;
    
    set i = i + 1;
  );
  
  resizeEdTabBar t.ETB_tabBar w h;
  
  _PAINTcontainer t.ETB_cont;
  _TOPwindow t.ETB_win;
  _TOPcontainer t.ETB_cont;
  0;
}


paintEdToolBar(t){
_TOPwindow t.ETB_win;
  _TOPcontainer t.ETB_cont;
  _PAINTcontainer t.ETB_cont;
  0;
}    


cbEdToolBarDbClick(cont, p, x, y, btn, mask){
let p -> [t cbfun] in
    exec cbfun with [t x y btn mask];
  0;
}


setEdToolBarDbClick(t, cbfun){
_CBcontainerDblClick t.ETB_cont @cbEdToolBarDbClick [t cbfun];
  0;
}


cbEdToolBarClick(cont, p, x, y, btn, mask){
let p -> [t cbfun] in
    exec cbfun with [t x y btn mask];
  0;
}


setEdToolBarClick(t, cbfun){
_CBcontainerClick t.ETB_cont @cbEdToolBarClick [t cbfun];
  0;
}


setEdToolBarVisible(t, mode){
let if !mode then WINDOW_HIDDEN else WINDOW_UNHIDDEN -> flag in
  (
    _SHOWwindow t.ETB_win flag;
    set t.ETB_bVisible = mode;
  );
  0;
}


crEdToolBar(chan, father, x, y, w, h, hmargin, vmargin, bgcolor, mode){
let if father == nil then WN_MENU else WN_CHILDINSIDE|WN_NOCAPTION|WN_NOBORDER -> flag in
  let _CRwindow chan father x y w h flag "" -> win in
  let _CRcontainerFromObjWin chan win 0 0 w h CO_CHILDINSIDE|CO_NOBORDER bgcolor "toolbar" -> cont in
  let mkEdToolBar[chan win cont [x y] [w h] mode bgcolor hmargin vmargin nil nil nil nil nil nil nil nil nil nil nil nil 1] -> t in
  (
    set t.ETB_iCurrentLpos = 0;
    set t.ETB_iCurrentRpos = w;
    set t.ETB_iCurrentTpos = 0;
    set t.ETB_iCurrentBpos = h;
    set t.ETB_fontTooltip = _CRfont chan 8 0 FF_PIXEL "Arial";
    _CBwinDestroy win @dsEdToolBar t;
    _TOPwindow t.ETB_win;
    _TOPcontainer t.ETB_cont;
    _PAINTcontainer t.ETB_cont;
    t;
  );
}



/* ********************************************************************************************* /
  Window
/ ********************************************************************************************* */

getEdWindowVisibleState(winstr){
winstr.EDW_bVisible;
}


setEdWindowCtrl3dEnable(winstr, state){
let sizelist winstr.EDW_lControl -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list winstr.EDW_lControl i -> ctrlstr in
    if ctrlstr.EDC_view3d == nil then nil else
      V3DEnableRender ctrlstr.EDC_view3d state;
    
    set i = i + 1;
  );
  
  let sizelist winstr.EDW_lSons -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list winstr.EDW_lSons i -> sonstr in
      setEdWindowCtrl3dEnable sonstr state;
    
    set i = i + 1;
  );  
  0;
}


setEdWindowVisible(winstr, state){
let if !state then 0 else 1 -> state in
  (
    set winstr.EDW_bVisible = state;
    _SHOWwindow winstr.EDW_win if !state then WINDOW_HIDDEN else WINDOW_UNHIDDEN;
    
    setEdWindowCtrl3dEnable winstr state;
  );
  0;
}


setEdWindowFocus(winstr){
_SETfocus winstr.EDW_win;
  0;
}


setEdWindowTop(winstr){
_TOPwindow winstr.EDW_win;
  0;
}


setEdWindowTopMost(winstr){
_TOPMOSTwindow winstr.EDW_win 3 1;
  _TOPMOSTwindow winstr.EDW_win 1 1;
  0;
}


setEdWindowName(winstr, name){
_SETwindowName winstr.EDW_win name;
  0;
}


getEdWindowToolBarSize(winstr){
let sizelist winstr.EDW_lToolbar -> size in
  let 0 -> xdecal in
  let 0 -> ydecal in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list winstr.EDW_lToolbar i -> tb in
      if !tb.ETB_bVisible then nil else
      (
        let tb.ETB_size -> [tw th] in
        if tb.ETB_modeflag & ETB_VERTICAL then
          set xdecal = xdecal + tw
        else if tb.ETB_modeflag & ETB_HORIZONTAL then
          set ydecal = ydecal + th
        else nil;
      );
      
      set i = i + 1;
    );  
    [xdecal ydecal]
  );
}


resizeEdWindowToolBar(winstr, w, h){
let sizelist winstr.EDW_lToolbar -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list winstr.EDW_lToolbar i -> elem in
    let elem.ETB_pos -> [tx ty] in
    let elem.ETB_size -> [tw th] in
    if elem.ETB_modeflag == nil then nil else
    let if elem.ETB_modeflag & ETB_VERTICAL then [tw (h - ty)] else [(w - tx) th] -> [tbw tbh] in
      sizeEdToolBar elem tx ty tbw tbh;
    
    set i = i + 1;
  );
  0;
}


dsEdWindowToolBar(winstr, tbstr){
set winstr.EDW_lToolbar = G2DremoveFromList winstr.EDW_lToolbar tbstr;
  dsEdToolBar nil tbstr;
  0;
}


crEdWindowToolBar(winstr, x, y, w, h, hmargin, vmargin, bgcolor, mode){
let crEdToolBar winstr.EDW_channel winstr.EDW_win x y w h hmargin vmargin bgcolor mode -> tbstr in
  (
    set winstr.EDW_lToolbar = tbstr::winstr.EDW_lToolbar;
    tbstr;
  );
}


calcEdWindowGroupSonPos(winstr){
let sizelist winstr.EDW_lSons -> size in
  let nil -> newy in
  let 0 -> i in  
  (
    while i < size do
    (
      let nth_list winstr.EDW_lSons i -> sonstr in
      if (sonstr.EDW_modeFlag & EDWIN_DIALOG) || (sonstr.EDW_modeFlag & EDWIN_POPUP) then nil else
      let _GETwindowExPositionSize sonstr.EDW_win -> [x y w h] in
        set newy = (if newy == nil then y else newy) + h;
      
      set i = i + 1;
    );
    newy;
  );
}


updateEdGroupWindowSons(winstr){
if !(winstr.EDW_modeFlag & EDWIN_GROUP) then nil else
  let sizelist winstr.EDW_lSons -> size in
  let nil -> newy in
  let 0 -> i in  
  (
    while i < size do
    (
      let nth_list winstr.EDW_lSons i -> sonstr in
      if (sonstr.EDW_modeFlag & EDWIN_DIALOG) || (sonstr.EDW_modeFlag & EDWIN_POPUP) then nil else
      let _GETwindowExPositionSize sonstr.EDW_win -> [x y w h] in
      (
        set newy = if newy == nil then y else newy;
        _SIZEwindowEx sonstr.EDW_win w h x newy;
        set newy = newy + h;
      );
      
      set i = i + 1;
    );
  );
  0;
}


getEdFrameYpos(winstr){
if !(winstr.EDW_father.EDW_modeFlag & EDWIN_GROUP) then nil else
  let sizelist winstr.EDW_father.EDW_lSons -> size in
  let nil -> newy in
  let 0 -> i in
  let nil -> sonstr in
  (
    while i < size && sonstr != winstr do
    (
      set sonstr = nth_list winstr.EDW_father.EDW_lSons i;
      if sonstr == winstr then nil else
      if (sonstr.EDW_modeFlag & EDWIN_DIALOG) || (sonstr.EDW_modeFlag & EDWIN_POPUP) then nil else
      let _GETwindowExPositionSize sonstr.EDW_win -> [x y w h] in
      (
        set newy = if newy == nil then y else newy;
        set newy = newy + h;
      );
     
      set i = i + 1;
    );
    newy;
  );
}


calcEdCoord(winstr){
let if winstr.EDW_father == nil then
      let _GETscreenSize -> [ww hh] in
        [ww hh-40]  
      else
      let _GETwindowPositionSize winstr.EDW_father.EDW_win -> [_ _ ww hh] in
        [ww hh]
  -> [fw fh] in
  let _GETwindowPositionSize winstr.EDW_win -> [x y w h] in
    set winstr.EDW_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
  0;
}


calcEdWindowDim(typ,x1,w,x2,l){
let max 1 (if typ&1 then x1 else 0)+(if typ&2 then w else 0)+(if typ&4 then x2 else 0) -> sum in
  let (x1 * ((l-x1-x2-w)+sum)) / sum -> xx in
  let (w * ((l-x1-x2-w)+sum)) / sum -> ww in
    [(if typ&1 then xx else x1) (if typ&2 then ww else w)];
}


calcEdWindowSizePos(winstr){
let winstr.EDW_coords -> [x1 y1 x2 y2 w h] in
  if !winstr.EDW_resizeFlag then
    [x1 y1 w h]
  else
  let if winstr.EDW_father==nil then
      let _GETscreenSize -> [tw th] in
      [tw th-40]
     else let _GETwindowSizePosition winstr.EDW_father.EDW_win -> [tw th _ _] in
     if tw == 0 || th == 0 then let winstr.EDW_father.EDW_coords -> [_ _ _ _ sw sh] in [sw sh] else [tw th]
  -> [fw fh] in
  (
    let calcEdWindowDim winstr.EDW_resizeFlag x1 w x2 fw -> [xx ww] in
    let calcEdWindowDim winstr.EDW_resizeFlag>>3 y1 h y2 fh -> [yy hh] in
      [xx yy ww hh]
  );
}


calcEdCtrlSizePos(ctrlstr){
let ctrlstr.EDC_coords -> [x1 y1 x2 y2 w h] in
  let ctrlstr.EDC_father.EDW_coords -> [_ _ _ _ ow oh] in
  let if w < 0 then (ow - (abs w)) else w -> w in
  let if h < 0 then (oh - (abs h)) else h -> h in
  
  let _GETwindowSizePosition ctrlstr.EDC_father.EDW_win -> [fw fh _ _] in
  (
    let calcEdWindowDim ctrlstr.EDC_resizeFlag x1 w x2 fw -> [xx ww] in
    let calcEdWindowDim ctrlstr.EDC_resizeFlag>>3 y1 h y2 fh -> [yy hh] in
      [xx yy ww hh]
  );
}


getEdVirtualWindowSize(winstr){
let _GETwindowPositionSize winstr.EDW_virtualWin -> [_ _ w h] in
   [w h];
}


getEdVirtualWindowPos(winstr){
let _GETwindowPositionSize winstr.EDW_virtualWin -> [x y _ _] in
   [x y];
}
   

getEdWindowSize(winstr){
let _GETwindowPositionSize winstr.EDW_win -> [x y w h] in
    [w h];
}


getEdWindowPos(winstr){
let _GETwindowPositionSize winstr.EDW_win -> [x y w h] in
    [x y];
}


getEdWindowPosSize(winstr){
let _GETwindowPositionSize winstr.EDW_win -> [x y w h] in
    [x y w h];
}


getEdWindowResizeFlags(winstr){
winstr.EDW_resizeFlag;
}


resizeEdWindowVirtualSize(winstr){
if winstr.EDW_virtualWin == nil then nil else
  let _GETwindowPositionSize winstr.EDW_virtualWin -> [ox oy _ _] in
  let _GETwindowPositionSize winstr.EDW_win -> [_ _ minw minh] in
  let minw -> neww in
  let minh -> newh in
  (
    let sizelist winstr.EDW_lSons -> size in
    let 0 -> i in
    (
      while i < size do
      (
        let nth_list winstr.EDW_lSons i -> sonstr in
        if sonstr.EDW_modeFlag & EDWIN_DIALOG then nil else
        let _GETwindowExPositionSize sonstr.EDW_win -> [x y w h] in
        let x + w -> nw in
        let y + h -> nh in
        let if nw > neww then nw else neww -> nnw in
        let if nh > newh then nh else newh -> nnh in        
        (
          set neww = nnw;
          set newh = nnh;
        );
        
        set i = i + 1;
      );
      _SIZEwindow winstr.EDW_virtualWin neww newh ox oy;
    );
  );
  0;
}


resizeEdWindow(winstr){
if (winstr.EDW_resizeFlag == nil) || (winstr.EDW_resizeFlag == EDWIN_RESIZE_NONE) || (winstr.EDW_modeFlag & EDWIN_DIALOG) && !(winstr.EDW_modeFlag & EDWIN_FRAME) then nil else
  if winstr.EDW_modeFlag & EDWIN_TAB then
  (
    let getEdWindowToolBarSize winstr.EDW_father -> [xdecal ydecal] in
    let getEdWindowSize winstr.EDW_father -> [w h] in
      _SIZEwindow winstr.EDW_win (w - xdecal) (h - ydecal) xdecal ydecal;
    0;
  )
  else if winstr.EDW_bMinimize != 1 then
  (
    let calcEdWindowSizePos winstr -> [x y w h] in
    let if (winstr.EDW_modeFlag & EDWIN_FRAME) then getEdFrameYpos winstr else y -> y in
      _SIZEwindow winstr.EDW_win w h x y;
    0;
  )
  else if (winstr.EDW_bMinimize) && (winstr.EDW_modeFlag & EDWIN_FRAME) then
  (
    let hd winstr.EDW_lToolbar -> tbstr in
    let tbstr.ETB_size -> [tw th] in
    let calcEdWindowSizePos winstr -> [x y w h] in
    let getEdFrameYpos winstr -> y in
    (
      _SIZEwindow winstr.EDW_win w th x y;
      0;
    );
  )
  else
  (
    let _GETwindowSizePosition winstr.EDW_father.EDW_win -> [w h _ _] in
    let winstr.EDW_tMdecal -> [hdecal vdecal] in
    let getEdWindowToolBarSize winstr.EDW_father -> [xdecal ydecal] in
    (
      _SIZEwindow winstr.EDW_win (w - xdecal) (h - ydecal) xdecal+hdecal ydecal+vdecal;
      _TOPwindow winstr.EDW_win;
      _SETfocus winstr.EDW_win;
    );
    0;
  );
  0;
}


setEdWindowPosSize(winstr, x, y, w, h){
_SIZEwindow winstr.EDW_win w h x y;
  calcEdCoord winstr;
  0;
}


setEdWindowSize(winstr, w, h){
let _GETwindowPositionSize winstr.EDW_win -> [x y _ _] in
    _SIZEwindow winstr.EDW_win w h x y;
  calcEdCoord winstr;
  0;
}


setEdWindowPos(winstr, x, y){
let _GETwindowPositionSize winstr.EDW_win -> [_ _ w h] in
    _SIZEwindow winstr.EDW_win w h x y;
  calcEdCoord winstr;
  0;
}


setEdWindowPosSizeEx(winstr, x, y, w, h){
_SIZEwindowEx winstr.EDW_win w h x y;
  calcEdCoord winstr;
  0;
}


setEdWindowSizeEx(winstr, w, h){
let _GETwindowPositionSize winstr.EDW_win -> [x y _ _] in
    _SIZEwindowEx winstr.EDW_win w h x y;
  calcEdCoord winstr;
  0;
}


setEdWindowPosEx(winstr, x, y){
let _GETwindowPositionSize winstr.EDW_win -> [_ _ w h] in
    _SIZEwindowEx winstr.EDW_win w h x y;
  calcEdCoord winstr;
  0;
}


setEdVirtualWindowPosSize(winstr, x, y, w, h){
_SIZEwindow winstr.EDW_virtualWin w h x y;
  0;
}


setEdVirtualWindowSize(winstr, w, h){
let _GETwindowPositionSize winstr.EDW_virtualWin -> [x y _ _] in
    _SIZEwindow winstr.EDW_virtualWin w h x y;
  0;
}


setEdVirtualWindowPos(winstr, x, y){
let _GETwindowPositionSize winstr.EDW_virtualWin -> [_ _ w h] in
    _SIZEwindow winstr.EDW_virtualWin w h x y;
  0;
}


setEdWindowResizeFlags(winstr, flags){
set winstr.EDW_resizeFlag = flags;
  calcEdCoord winstr;
  0;
}


cbEdVirtualWindowSize(win, winstr, wv, hv){
exec winstr.EDW_cbVirtualSize with [winstr wv hv];
  0;
}


cbEdVirtualWindowMove(win, winstr, x, y){
exec winstr.EDW_cbVirtualMove with [winstr x y];
  0;
}


cbEdWindowMove(win, winstr, x, y){
// update the minimum size of the father virtual window on son modification
  resizeEdWindowVirtualSize winstr.EDW_father;
  exec winstr.EDW_cbMove with [winstr x y];
  0;
}


updateEdCtrlSize(winstr){
let sizelist winstr.EDW_lControl -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list winstr.EDW_lControl i -> ctrlstr in
    let ctrlstr.EDC_coords -> [_ _ _ _ cw ch] in
    let calcEdCtrlSizePos ctrlstr -> [x y w h] in
    // + 1 because of the border size
    (
      if ctrlstr.EDC_label != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in      
      (
        _POSITIONtext ctrlstr.EDC_label x y w h;
        0;
      )
      else if ctrlstr.EDC_editText != nil then     
      (
        _POSITIONtext ctrlstr.EDC_editText x y w+1 h+1;
        0;
      )
      else if ctrlstr.EDC_editLine != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in      
      (
        _POSITIONtext ctrlstr.EDC_editLine x y w+1 h+1;
        0;
      )
      else if ctrlstr.EDC_text != nil then   
      (
        _POSITIONtext ctrlstr.EDC_text x y w+1 h+1;
        0;
      )      
      else if ctrlstr.EDC_button != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in      
      (
        _POSITIONbutton ctrlstr.EDC_button x y w h;
        0;
      )
      else if ctrlstr.EDC_check != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in
      (
        _POSITIONcheck ctrlstr.EDC_check x y w h;
        0;
      )
      else if ctrlstr.EDC_list != nil then    
      (
        let ctrlstr.EDC_list -> [list _] in
        _POSITIONlist list x y w+1 h+1;
        0;
      )
      else if ctrlstr.EDC_select != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in      
      (
        _POSITIONcombo ctrlstr.EDC_select x y w h;
        0;
      )
      else if ctrlstr.EDC_tree != nil then     
      (
        let ctrlstr.EDC_tree -> [tree _ _ _ _] in
        _POSITIONtree tree x y w+1 h+1;
        0;
      )
      else if ctrlstr.EDC_bitmap != nil then
      // the init size is the minimum size
      let if w <= cw then 2 else w -> w in
      let if h <= ch then 2 else h -> h in      
      (
        let ctrlstr.EDC_bitmap -> [cont alphabmp ocbmp _ _] in
        _SIZEcontainer cont x y w h;
        0;
      )
      else if ctrlstr.EDC_bitmapList != nil then
      // the init size is the minimum size
      let if w <= cw then 2 else w -> w in
      let if h <= ch then 2 else h -> h in      
      (
        let ctrlstr.EDC_bitmapList -> [cont _ _ _ _ _ _] in
        _SIZEcontainer cont x y w h;
        0;
      )
      else if ctrlstr.EDC_editFloat != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in      
      (
        let ctrlstr.EDC_editFloat -> [txt cont _ _ _ _ _ _ _ _ _ _ _] in
        let _GETcontainerExPositionSize cont -> [_ _ bw bh] in
        (
          _POSITIONtext txt x y ((w - bw) + 1) (h + 1);
          _MOVEcontainer cont (x + (w - bw)) y;
        );
        0;
      )
      else if ctrlstr.EDC_view3d != nil then
      // the init size is the minimum size
      let if w <= 1 then 1 else w -> w in
      let if h <= 1 then 1 else h -> h in      
      (
        V3DresizeView ctrlstr.EDC_view3d x y w h;
        0;
      )
      else if ctrlstr.EDC_colorButton != nil then
      // the init size is the minimum size
      let if h <= ch then ch else h -> h in      
      (
        let ctrlstr.EDC_colorButton -> [btn obmp winstr color mode cbfun] in
        let if !mode then (G2Drgb2bgr color) else G2Dbgra2bgr (G2Drgba2bgra color) -> bgrcolor in
        let _FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgrcolor -> bmp in
        (
          _DSbitmap obmp;
          _POSITIONbutton btn x y w h;
          _SETbuttonBitmap btn bmp;
          mutate ctrlstr.EDC_colorButton <- [_ bmp _ color _ _];
          _PAINTbutton btn;
        );
        0;
      )
      else nil;
    );
    
    set i = i + 1;
  );
  0;
}


cbEdWindowSize(win, winstr, w, h){
let sizelist winstr.EDW_lSons -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list winstr.EDW_lSons i -> son in
      resizeEdWindow son;
    
    set i = i + 1;
  );
  
  // update the position of the sons of a father group
  updateEdGroupWindowSons winstr.EDW_father;
  
  // update the minimum size of the virtual window
  resizeEdWindowVirtualSize winstr;
  
  // update the minimum size of the father virtual window on son modification
  resizeEdWindowVirtualSize winstr.EDW_father;
  
  // update controls size
  updateEdCtrlSize winstr;
  
  // update toolbar size
  let getEdWindowToolBarSize winstr.EDW_father -> [xdecal ydecal] in  
    resizeEdWindowToolBar winstr (w - xdecal) (h - ydecal);
  
  exec winstr.EDW_cbSize with [winstr w h];
  0;
}


maximizeOrMinimizeEdWindow(winstr, hdecal, vdecal){
if winstr.EDW_bMinimize != 1 then
  (
    set winstr.EDW_bMinimize = 1;
    set winstr.EDW_tMdecal = [hdecal vdecal];
    
    let _GETwindowSizePosition winstr.EDW_father.EDW_win -> [w h _ _] in
    let getEdWindowToolBarSize winstr.EDW_father -> [xdecal ydecal] in
    (
      // Hide all brothers
      let sizelist winstr.EDW_father.EDW_lSons -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list winstr.EDW_father.EDW_lSons i -> brostr in
        if (brostr == winstr) || (brostr.EDW_modeFlag & EDWIN_DIALOG|EDWIN_POPUP) then nil else
          setEdWindowVisible brostr 0;
        
        set i = i + 1;
      ); 
    
      _SIZEwindow winstr.EDW_win (w - xdecal) (h - ydecal) xdecal+hdecal ydecal+vdecal;
      _TOPwindow winstr.EDW_win;
      _SETfocus winstr.EDW_win;
    );
  )
  else
  (
    set winstr.EDW_bMinimize = 0;
    set winstr.EDW_tMdecal = nil;
    
    // Show all brothers
    let sizelist winstr.EDW_father.EDW_lSons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list winstr.EDW_father.EDW_lSons i -> brostr in
      if brostr == winstr then nil else
        setEdWindowVisible brostr 1;
      
      set i = i + 1;
    );     
    
    resizeEdWindow winstr;

    _TOPwindow winstr.EDW_win;
    _SETfocus winstr.EDW_win;
  );  
  0;
}


cbEdWindowKeyDown(win, winstr, key, scode){
exec winstr.EDW_cbKeyDown with [winstr key scode];
  
  // if dialog and escape key then close window
  if (winstr.EDW_modeFlag & EDWIN_DIALOG) && key == 1 then
    dsEdWindow winstr
  else if (winstr.EDW_father.EDW_modeFlag & EDWIN_DIALOG) && key == 1 then
    dsEdWindow winstr.EDW_father
  else nil;
  0;
}


cbEdWindowDropFile(win, winstr, x, y, lp){
exec winstr.EDW_cbDrop with [winstr x y lp];
  0;
}


cbEdWindowKeyUp(win, winstr, key){
exec winstr.EDW_cbKeyUp with [winstr key];
  0;
}


setEdwindowCbKeyDown(winstr, cbfun){
set winstr.EDW_cbKeyDown = cbfun;
  0;
}


setEdwindowCbKeyUp(winstr, cbfun){
set winstr.EDW_cbKeyUp= cbfun;
  0;
}


setEdwindowCbSize(winstr, cbfun){
set winstr.EDW_cbSize = cbfun;
  0;
}


setEdwindowCbMove(winstr, cbfun){
set winstr.EDW_cbMove = cbfun;
  0;
}


setEdwindowCbVirtualMove(winstr, cbfun){
set winstr.EDW_cbVirtualMove = cbfun;
  0;
}


setEdwindowCbVirtualSize(winstr, cbfun){
set winstr.EDW_cbVirtualSize = cbfun;
  0;
}


setEdwindowCbDestroy(winstr, cbfun){
set winstr.EDW_cbDestroy = cbfun;
  0;
}


setEdwindowCbClose(winstr, cbfun){
set winstr.EDW_cbClose = cbfun;
  0;
}


setEdwindowCbDrop(winstr, cbfun){
set winstr.EDW_cbDrop = cbfun;
  0;
}


dsEdWindow(winstr){
dsEdToolBarList winstr.EDW_lToolbar;
  set winstr.EDW_lToolbar = nil;
  
  let sizelist winstr.EDW_lSons -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list winstr.EDW_lSons i -> son in
      dsEdWindow son;
    
    set i = i + 1;
  );
  
  exec winstr.EDW_cbDestroy with [winstr];
  
  // remove window from father
  set winstr.EDW_father.EDW_lSons = G2DremoveFromList winstr.EDW_father.EDW_lSons winstr;
  
  if winstr.EDW_virtualWin == nil then nil else
    _DSwindow winstr.EDW_virtualWin;   
  
  dsEdWindowCtrlList winstr.EDW_lControl;

  if !(winstr.EDW_modeFlag & EDWIN_MODAL) then nil else
    _ENwindow winstr.EDW_father.EDW_win 1;
  
  _DSwindow winstr.EDW_win;
  0;
}


cbEdWindowClose(win, winstr){
if winstr.EDW_cbClose != nil then
    exec winstr.EDW_cbClose with [winstr]
  else
    dsEdWindow winstr;
  0;
}


cbEdWindowDestroy(win, winstr){
dsEdWindow winstr;
  0;
}
  

cbEdVirtualWindowWheel(win, winstr, x, y, delta, btn){
let delta * 10 -> delta in
  if winstr.EDW_virtualWin == nil then nil else
  (
    let _GETwindowPositionSize winstr.EDW_win -> [_ _ ww wh] in
    let _GETwindowPositionSize winstr.EDW_virtualWin -> [vx vy vw vh] in
    let if (vy + delta) <= (-(vh - wh)) then (-(vh - wh)) else if (vy + delta) >= 0 then 0 else (vy + delta) -> my in
      _MVwindow winstr.EDW_virtualWin vx my;
  );
  0;
}
  

cbEdVirtualWindowCursorMove(win, winstr, dx, dy, btn){
let _GETcursorPos winstr.EDW_win -> [x y] in
  let _GETwindowPositionSize winstr.EDW_win -> [_ _ ww wh] in
  let _GETwindowPositionSize winstr.EDW_virtualWin -> [vx vy vw vh] in
  if btn & 16 then
  if x == nil || y == nil || vx == nil || vy == nil || vw == nil || vh == nil then nil else
  if winstr.EDW_tLastCursorPos == nil then
  (
    set winstr.EDW_tLastCursorPos = [(x - vx) (y - vy)];
    0;
  )
  else
  let winstr.EDW_tLastCursorPos -> [cx cy] in
  let if (x - cx) <= (-(vw - ww)) then (-(vw - ww)) else if (x - cx) >= 0 then 0 else (x - cx) -> mx in
  let if (y - cy) <= (-(vh - wh)) then (-(vh - wh)) else if (y - cy) >= 0 then 0 else (y - cy) -> my in
  (
    _MVwindow winstr.EDW_virtualWin mx my;
    0;  
  )
  else nil;
  0;
}


cbEdVirtualWindowClick(win, winstr, dx, dy, btn){
_SETfocus win;
  0;
}


cbEdVirtualWindowUnClick(win, winstr, x, y, btn){
set winstr.EDW_tLastCursorPos = nil;
  0;
}


setEdWindowIcon(winstr, file){
let _checkpack file -> picon in
    _SETwindowIcon winstr.EDW_win picon;
  winstr;
}


crEdWindow(chan, fatherstr, x, y, w, h, flags, resize, mode, title){
let if flags == nil then WN_NORMAL|WN_DRAGDROP|WN_NOSCOL else flags|WN_DRAGDROP|WN_NOSCOL -> flags in
  let if mode == nil then
        flags
      else if mode & EDWIN_DIALOG then
        flags|WN_DIALOG|WN_NOSCOL
      else if mode & EDWIN_POPUP then
        flags|WN_CHILDMENU|WN_CHILDINSIDE|WN_NOSCOL|WN_TOPMOST
      else if mode & EDWIN_FRAME then
        WN_CHILDINSIDE|WN_NOBORDER
      else flags
  -> modeflag in
  let if fatherstr.EDW_virtualWin == nil then fatherstr.EDW_win else fatherstr.EDW_virtualWin -> fatherwin in
  let mkEdWindow [nil nil fatherstr.EDW_win nil nil nil 0 nil resize 0 nil nil nil 0 1 nil nil nil nil nil nil nil nil nil nil] -> winstr in
  let if (fatherstr.EDW_modeFlag & EDWIN_GROUP) && !(mode & EDWIN_POPUP) && !(mode & EDWIN_DIALOG) then (let calcEdWindowGroupSonPos fatherstr -> ny in if ny == nil then y else ny) else y -> y in
  (
    if !(mode & EDWIN_MODAL) then nil else
      _ENwindow fatherstr.EDW_win 0;
      
    set winstr.EDW_channel = chan;
    set winstr.EDW_father = fatherstr;
    set winstr.EDW_modeFlag = if mode == nil then 0 else mode;
    set winstr.EDW_win = _CRwindow winstr.EDW_channel fatherwin x y w h modeflag title;
    
    set fatherstr.EDW_lSons = G2Dlcat fatherstr.EDW_lSons winstr::nil;
    
    // update the minimum size of the father virtual window on son add
    resizeEdWindowVirtualSize fatherstr;
    
    calcEdCoord winstr;
    
    _CBwinSize winstr.EDW_win @cbEdWindowSize winstr;
    _CBwinMove winstr.EDW_win @cbEdWindowMove winstr;
    _CBwinDestroy winstr.EDW_win @cbEdWindowDestroy winstr;
    _CBwinClose winstr.EDW_win @cbEdWindowClose winstr;
    
    _CBwinClick winstr.EDW_win @cbEdVirtualWindowClick fatherstr;
    _CBwinUnclick winstr.EDW_win @cbEdVirtualWindowUnClick fatherstr;
    _CBcursorMove winstr.EDW_win @cbEdVirtualWindowCursorMove fatherstr;
    _CBwinWheel winstr.EDW_virtualWin @cbEdVirtualWindowWheel fatherstr;
    
    _CBwinKeydown winstr.EDW_win @cbEdWindowKeyDown winstr;
    _CBwinKeyup winstr.EDW_win @cbEdWindowKeyUp winstr;
    
    _CBwinDropFile winstr.EDW_win @cbEdWindowDropFile winstr;
    
    _SETfocus winstr.EDW_win;
    winstr;
  );
}


crEdScrollWindow(chan, fatherstr, x, y, w, h, flags, resize, mode, title){
let if flags == nil then WN_NORMAL|WN_VSCROLL|WN_HSCROLL|WN_DRAGDROP|WN_NOSCOL else flags|WN_DRAGDROP|WN_NOSCOL -> flags in
  let if fatherstr.EDW_virtualWin == nil then fatherstr.EDW_win else fatherstr.EDW_virtualWin -> fatherwin in
  let mkEdWindow [nil nil fatherstr.EDW_win nil nil nil 0 nil resize 0 nil nil nil 0 1 nil nil nil nil nil nil nil nil nil nil] -> winstr in
  let if fatherstr.EDW_modeFlag & EDWIN_GROUP then (let calcEdWindowGroupSonPos fatherstr -> ny in if ny == nil then y else ny) else y -> y in
  let _CRscrollWindow winstr.EDW_channel fatherwin x y w h w h flags title -> [win vwin] in
  (
    set winstr.EDW_channel = chan;
    set winstr.EDW_father = fatherstr;
    set winstr.EDW_modeFlag = if mode == nil then 0 else mode;
    set winstr.EDW_win = win;
    set winstr.EDW_virtualWin = vwin;
    
    set fatherstr.EDW_lSons = winstr::fatherstr.EDW_lSons;
    
    // update the minimum size of the father virtual window on son add
    resizeEdWindowVirtualSize fatherstr;
    
    calcEdCoord winstr;
    
    _CBwinSize winstr.EDW_win @cbEdWindowSize winstr;
    _CBwinMove winstr.EDW_win @cbEdWindowMove winstr;
    _CBwinDestroy winstr.EDW_win @cbEdWindowDestroy winstr;
    _CBwinClose winstr.EDW_win @cbEdWindowClose winstr;
    
    _CBwinKeydown winstr.EDW_win @cbEdWindowKeyDown winstr;
    _CBwinKeyup winstr.EDW_win @cbEdWindowKeyUp winstr;
    
    // pass the scroll bug force the update
    _CBwinSize winstr.EDW_virtualWin @cbEdVirtualWindowSize winstr;
    _CBwinMove winstr.EDW_virtualWin @cbEdVirtualWindowMove winstr;
    _CBwinClick winstr.EDW_virtualWin @cbEdVirtualWindowClick winstr;
    _CBwinUnclick winstr.EDW_virtualWin @cbEdVirtualWindowUnClick winstr;
    _CBcursorMove winstr.EDW_virtualWin @cbEdVirtualWindowCursorMove winstr;
    _CBwinWheel winstr.EDW_virtualWin @cbEdVirtualWindowWheel winstr;
    
    _CBwinKeydown winstr.EDW_virtualWin @cbEdWindowKeyDown winstr;
    _CBwinKeyup winstr.EDW_virtualWin @cbEdWindowKeyUp winstr;
    
    _SETfocus winstr.EDW_virtualWin;
    winstr;
  );
}


crEdGroupWindow(chan, fatherstr, x, y, w, h, flags, resize, title){
crEdScrollWindow chan fatherstr x y w h flags resize EDWIN_GROUP title;
}


crEdDialogWindow(chan, fatherstr, x, y, w, h, flags, resize, title){
crEdWindow chan fatherstr x y w h flags resize EDWIN_DIALOG title;
}


crEdModalDialogWindow(chan, fatherstr, x, y, w, h, flags, resize, title){
crEdWindow chan fatherstr x y w h flags resize EDWIN_DIALOG|EDWIN_MODAL title;
}


crEdPopupWindow(chan, fatherstr, x, y, w, h, flags, resize, title){
crEdWindow chan fatherstr x y w h flags resize EDWIN_POPUP title;
}


cbEdFrameMinMax(tbstr, check, btn, mask, state, winstr){
let _GETwindowPositionSize winstr.EDW_win -> [cx cy cw ch] in
  if winstr.EDW_bMinimize != 1 then
  (
    set winstr.EDW_bMinimize = 1;
    
    let hd winstr.EDW_lToolbar -> tbstr in
    let tbstr.ETB_size -> [tw th] in
      _SIZEwindow winstr.EDW_win cw th cx cy;
      
    _TOPwindow winstr.EDW_win;
    _SETfocus winstr.EDW_win;
  )
  else
  (
    set winstr.EDW_bMinimize = 0;
    resizeEdWindow winstr;

    _TOPwindow winstr.EDW_win;
    _SETfocus winstr.EDW_win;
  );
  0;
}


cbEdDbClickFrameWindowTitle(cont, param, x, y, btn, mask){
let param -> [winstr minmaxchk] in
  if btn != 1 then nil else
  (
    let _GETwindowPositionSize winstr.EDW_win -> [cx cy cw ch] in
    if winstr.EDW_bMinimize != 1 then
    (
      set winstr.EDW_bMinimize = 1;
      _SETcompCheckState minmaxchk CHK_CHECKED;
      
      let hd winstr.EDW_lToolbar -> tbstr in
      let tbstr.ETB_size -> [tw th] in
        _SIZEwindow winstr.EDW_win cw th cx cy;
          
      _TOPwindow winstr.EDW_win;
      _SETfocus winstr.EDW_win;
    )
    else
    (
      set winstr.EDW_bMinimize = 0;
      _SETcompCheckState minmaxchk CHK_UNCHECKED;
      resizeEdWindow winstr;
  
      _TOPwindow winstr.EDW_win;
      _SETfocus winstr.EDW_win;
    );
    _PAINTcontainer cont;
  );
  0;
}


crEdFrameWindow(chan, fatherstr, x, y, w, h, resize, themestr, title, minimizebuble){
let if themestr == nil then (if EdDefaultTheme == nil then (set EdDefaultTheme = makeEdThemeResources chan) else EdDefaultTheme) else themestr -> themestr in

  let crEdWindow chan fatherstr x y w h nil resize EDWIN_FRAME title -> winstr in
  let crEdWindowToolBar winstr 0 0 w themestr.EDT_iFrameBarHeight 5 0 themestr.EDT_iFrameBarColor ETB_HORIZONTAL -> tbstr in
  let crEdToolBarText tbstr title themestr.EDT_sFrameFontName themestr.EDT_iFrameFontSize FF_PIXEL|FF_WEIGHT themestr.EDT_iFrameFontColor nil ETB_ALIGN_LEFT -> txttitle in
  let crEdToolBarCheck tbstr themestr.EDT_abmpFrameFold ETB_ALIGN_RIGHT minimizebuble mkfun6 @cbEdFrameMinMax winstr -> minmaxchk in
  (
    _CBcontainerDblClick tbstr.ETB_cont @cbEdDbClickFrameWindowTitle [winstr minmaxchk];

    paintEdToolBar tbstr;
    winstr;
  );
}


crEdMainWindow(chan, fatherwin, x, y, w, h, flags, title){
let if flags == nil then WN_NORMAL|WN_DRAGDROP|WN_NOSCOL else flags|WN_DRAGDROP|WN_NOSCOL -> flags in
  let mkEdWindow [nil nil fatherwin nil nil nil 0 nil 0 0 nil nil nil 0 1 nil nil nil nil nil nil nil nil nil nil] -> winstr in
  let _GETactiveXWindow chan 0 "Scol" -> winAX in
  (
    set winstr.EDW_channel = chan;
    
    if winAX ==nil then 
    (
      set winstr.EDW_win = _CRwindow winstr.EDW_channel fatherwin x y w h flags title;
    )
    else
    let _GETwindowPositionSize winAX -> [_ _ w h] in
    ( 
      set winstr.EDW_bIsAx = 1;
      set winstr.EDW_win = _CRwindow winstr.EDW_channel winAX 0 0 w h WN_CHILD|WN_NOBORDER|WN_DRAGDROP "WebDetect";
    );
    
    calcEdCoord winstr;
    
    _CBwinSize winstr.EDW_win @cbEdWindowSize winstr;
    _CBwinDestroy winstr.EDW_win @cbEdWindowDestroy winstr;
    _CBwinClose winstr.EDW_win @cbEdWindowClose winstr;
    _CBwinKeydown winstr.EDW_win @cbEdWindowKeyDown winstr;
    _CBwinKeyup winstr.EDW_win @cbEdWindowKeyUp winstr;
    _CBwinDropFile winstr.EDW_win @cbEdWindowDropFile winstr;
    
    winstr;
  );
}


getEdWindowIsAX(winstr){
winstr.EDW_bIsAx;
}


/* ********************************************************************************************* /
  Controls
/ ********************************************************************************************* */

getEdCtrlLabel(ctrlstr){
ctrlstr.EDC_label;
}

getEdCtrlText(ctrlstr){
ctrlstr.EDC_text;
}

getEdCtrlEditText(ctrlstr){
ctrlstr.EDC_editText;
}

getEdCtrlTextLine(ctrlstr){
ctrlstr.EDC_editLine;
}

getEdCtrlButton(ctrlstr){
ctrlstr.EDC_button;
}

getEdCtrlCheck(ctrlstr){
ctrlstr.EDC_check;
}

getEdCtrlRadio(ctrlstr){
ctrlstr.EDC_check;
}

getEdCtrlList(ctrlstr){
let ctrlstr.EDC_list -> [list _] in list;
}

getEdCtrlTree(ctrlstr){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in tree;
}

getEdCtrlSelect(ctrlstr){
ctrlstr.EDC_select;
}

getEdCtrlFloat(ctrlstr){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown minval maxval incre nb0 _ _ _ _ _] in txt;
}

getEdCtrlView3d(ctrlstr){
ctrlstr.EDC_view3d;
}



/* ********************************************************************************************* /
  Control text label
/ ********************************************************************************************* */
getEdCtrlLabelValue(ctrlstr){
_GETtext ctrlstr.EDC_label;
}


setEdCtrlLabelValue(ctrlstr, val){
_SETtext ctrlstr.EDC_label val;
  0;
}


setEdCtrlLabelEnable(ctrlstr, state){
_ENtext ctrlstr.EDC_label state;
  0;
}


crEdCtrlLabel(winstr, x, y, w, h, value, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRtext ctrlstr.EDC_channel father x y w h ET_AHSCROLL|ET_ALIGN_LEFT value -> txt in
  (
    set ctrlstr.EDC_label = txt;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlLabel(ctrlstr){
_DStext ctrlstr.EDC_label;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Text
/ ********************************************************************************************* */
getEdCtrlTextValue(ctrlstr){
_GETtext ctrlstr.EDC_text;
}


setEdCtrlTextValue(ctrlstr, val){
_SETtext ctrlstr.EDC_text val;
  0;
}


addEdCtrlTextValue(ctrlstr, val){
let _GETtext ctrlstr.EDC_text -> curtext in
  let if (curtext == nil) || (!strcmp curtext "") then val else strcatn curtext::"\n"::val::nil -> val in
    _SETtext ctrlstr.EDC_text val;
  0;
}


setEdCtrlTextEnable(ctrlstr, state){
_ENtext ctrlstr.EDC_text state;
  0;
}


cbEdCtrlTextChange(txt, p){
let p -> [ctrlstr cbfun] in
  let _GETtext ctrlstr.EDC_text -> val in
    exec cbfun with [ctrlstr val];
  0;
}


setEdCtrlTextCbChange(ctrlstr, cbfun){
_CBtext ctrlstr.EDC_text @cbEdCtrlTextChange [ctrlstr cbfun];
  0;
}


crEdCtrlText(winstr, x, y, w, h, value, flags, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRtext ctrlstr.EDC_channel father x y w h (if flags == nil then ET_BORDER|ET_AHSCROLL|ET_AVSCROLL|ET_VSCROLL|ET_TABFOCUS else flags) value -> txt in
  (
    set ctrlstr.EDC_text = txt;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlText(ctrlstr){
_DStext ctrlstr.EDC_text;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Edit Text
/ ********************************************************************************************* */
getEdCtrlEditTextValue(ctrlstr){
_GETtext ctrlstr.EDC_editText;
}


setEdCtrlEditTextValue(ctrlstr, val){
_SETtext ctrlstr.EDC_editText val;
  0;
}


setEdCtrlEditTextEnable(ctrlstr, state){
_ENtext ctrlstr.EDC_editText state;
  0;
}


cbEdCtrlEditTextChange(txt, p){
let p -> [ctrlstr cbfun] in
  let _GETtext ctrlstr.EDC_editText -> val in
    exec cbfun with [ctrlstr val];
  0;
}


setEdCtrlEditTextCbChange(ctrlstr, cbfun){
_CBtext ctrlstr.EDC_editText @cbEdCtrlEditTextChange [ctrlstr cbfun];
  0;
}


crEdCtrlEditText(winstr, x, y, w, h, value, flags, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CReditText ctrlstr.EDC_channel father x y w h (if flags == nil then ET_BORDER|ET_AHSCROLL|ET_AVSCROLL|ET_HSCROLL|ET_VSCROLL|ET_TABFOCUS else flags) value -> txt in
  (
    set ctrlstr.EDC_editText = txt;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlEditText(ctrlstr){
_DStext ctrlstr.EDC_editText;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Text edit line
/ ********************************************************************************************* */
getEdCtrlTextLineValue(ctrlstr){
_GETtext ctrlstr.EDC_editLine;
}


setEdCtrlTextLineValue(ctrlstr, val){
_SETtext ctrlstr.EDC_editLine val;
  0;
}


setEdCtrlTextLineEnable(ctrlstr, state){
_ENtext ctrlstr.EDC_editLine state;
  0;
}


cbEdCtrlTextLineChange(txt, p){
let p -> [ctrlstr cbfun] in
  let _GETtext ctrlstr.EDC_editLine -> val in
    exec cbfun with [ctrlstr val];
  0;
}


setEdCtrlTextLineCbChange(ctrlstr, cbfun){
_CBtext ctrlstr.EDC_editLine @cbEdCtrlTextLineChange [ctrlstr cbfun];
  0;
}


cbEdCtrlTextLineValidate(txt, p, val){
let p -> [ctrlstr cbfun] in
    exec cbfun with [ctrlstr val];
  0;
}


setEdCtrlTextLineCbValidate(ctrlstr, cbfun){
_CBlineOk ctrlstr.EDC_editLine @cbEdCtrlTextLineValidate [ctrlstr cbfun];
  0;
}


crEdCtrlTextLine(winstr, x, y, w, h, value, flags, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CReditLine ctrlstr.EDC_channel father x y w h (if flags == nil then ET_BORDER|ET_AHSCROLL|ET_TABFOCUS else flags) value -> txt in
  (
    set ctrlstr.EDC_editLine = txt;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


setEdctrlTextLineFocus(ctrlstr){
_SETtextFocus ctrlstr.EDC_editLine;
}


dsEdCtrlTextLine(ctrlstr){
_DStext ctrlstr.EDC_editLine;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Button
/ ********************************************************************************************* */
setEdCtrlButtonEnable(ctrlstr, state){
_ENbutton ctrlstr.EDC_button state;
  0;
}


cbEdCtrlButton(btn, p){
let p -> [ctrlstr cbfun] in
    exec cbfun with [ctrlstr];
  0;
}


setEdCtrlButtonCb(ctrlstr, cbfun){
_CBbutton ctrlstr.EDC_button @cbEdCtrlButton [ctrlstr cbfun];
  0;
}


crEdCtrlButton(winstr, x, y, w, h, value, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRbutton ctrlstr.EDC_channel father x y w h PB_TABFOCUS value -> button in
  (
    set ctrlstr.EDC_button = button;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlButton(ctrlstr){
_DSbutton ctrlstr.EDC_button;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}
  

/* ********************************************************************************************* /
  Control Check / Radio
/ ********************************************************************************************* */
getEdCtrlCheckState(ctrlstr){
_GETcheck ctrlstr.EDC_check;
}


setEdCtrlCheckState(ctrlstr, state){
_SETcheck ctrlstr.EDC_check state;
  0;
}


setEdCtrlCheckEnable(ctrlstr, state){
_ENcheck ctrlstr.EDC_check state;
  0;
}


cbEdCtrlCheckState(chk, p, state){
let p -> [ctrlstr cbfun] in
    exec cbfun with [ctrlstr state];
  0;
}


setEdCtrlCheckCbState(ctrlstr, cbfun){
_CBcheck ctrlstr.EDC_check @cbEdCtrlCheckState [ctrlstr cbfun];
  0;
}


getEdCtrlRadioState(ctrlstr){
_GETcheck ctrlstr.EDC_check;
}


setEdCtrlRadioState(ctrlstr, state){
_SETcheck ctrlstr.EDC_check state;
  0;
}


setEdCtrlRadioEnable(ctrlstr, state){
_ENcheck ctrlstr.EDC_check state;
  0;
}


setEdCtrlRadioCbState(ctrlstr, cbfun){
_CBcheck ctrlstr.EDC_check @cbEdCtrlCheckState [ctrlstr cbfun];
  0;
}


crEdCtrlCheck(winstr, x, y, w, h, value, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRcheck ctrlstr.EDC_channel father x y w h CH_TABFOCUS value -> check in
  (
    set ctrlstr.EDC_check = check;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlCheck(ctrlstr){
_DScheck ctrlstr.EDC_check;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


crEdCtrlRadio(winstr, x, y, w, h, value, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRcheck ctrlstr.EDC_channel father x y w h CH_RADIO|CH_TABFOCUS value -> check in
  (
    set ctrlstr.EDC_check = check;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlRadio(ctrlstr){
_DScheck ctrlstr.EDC_check;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control List
/ ********************************************************************************************* */

getEdCtrlListNbElems(ctrlstr){
let ctrlstr.EDC_list -> [list lp] in
    _GETlistCount list;
}


getEdCtrlListElemByName(ctrlstr, name){
let ctrlstr.EDC_list -> [_ l] in
  let sizelist l -> size in
  let 0 -> i in
  let nil -> ret in
  (
    while i < size && ret == nil do
    (
      let nth_list l i -> elt in
      let elt -> [p [val p]] in
        if (!strcmpi val name) then
          set ret = elt
        else nil;
      
      set i = i + 1;
    );
    ret;
  );
}
  

fillEdCtrlList(ctrlstr, lparam){
let ctrlstr.EDC_list -> [list _] in
  let nil -> lp in
  (
    _RSTlist list;
    
    let sizelist lparam -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lparam i -> elt in
      (
        _ADDlist list i elt;
        set lp = G2Dlcat lp [i [elt [nil nil]]]::nil;
      );
      set i = i + 1;
    );
    mutate ctrlstr.EDC_list <- [_ lp];
    _SELlist list 0;
  );
  0;
}


addEdCtrlList(ctrlstr, name, lval, type){
let ctrlstr.EDC_list -> [list lp] in
  let _GETlistCount list -> pos in
  (
    _ADDlist list pos name;
    mutate ctrlstr.EDC_list <- [_ G2Dlcat lp [pos [name [lval type]]]::nil];
  );
  0;
}


getEdCtrlListElems(ctrlstr){
let ctrlstr.EDC_list -> [list lp] in
  let sizelist lp -> size in
  let 0 -> i in
  let nil -> elems in
  (
    while i < size do
    (
      let nth_list lp i -> [_ [elt _]] in
        set elems = G2Dlcat elems elt::nil;
      
      set i = i + 1;
    );
    elems;
  );
}


getEdCtrlListElem(ctrlstr, elt){
let ctrlstr.EDC_list -> [list lp] in
  let getEdCtrlListElemByName ctrlstr elt -> [i [n p]] in
    p;
}


getEdCtrlListElemByParams(ctrlstr, params){
let ctrlstr.EDC_list -> [_ l] in
  let sizelist l -> size in
  let 0 -> i in
  let nil -> ret in
  (
    while i < size && ret == nil do
    (
      let nth_list l i -> elt in
      let elt -> [pos [val p]] in
      let p -> [lp type] in
        if (!strcmpi strcatn lp strcatn params) then
          set ret = p
        else nil;
      
      set i = i + 1;
    );
    ret;
  );
}


getEdCtrlListElemPosByParams(ctrlstr, params){
let ctrlstr.EDC_list -> [list l] in
  let sizelist l -> size in
  let 0 -> i in
  let nil -> ret in
  (
    while i < size && ret == nil do
    (
      let nth_list l i -> elt in
      let elt -> [pos [val p]] in
      let p -> [lp type] in
        if (!strcmpi strcatn lp strcatn params) then
          set ret = pos
        else nil;
      
      set i = i + 1;
    );
    ret;
  );
}


refreshEdCtrlList(ctrlstr){
let ctrlstr.EDC_list -> [list lp] in
  let nil -> ln in
  (
    _RSTlist list;
    
    let sizelist lp -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lp i -> [_ [elt p]] in
      (
        _ADDlist list i elt;
        set ln = G2Dlcat ln [i [elt p]]::nil;
      );
      set i = i + 1;
    );
    mutate ctrlstr.EDC_list <- [_ ln];
  );
  0;
}


delEdCtrlList(ctrlstr, elt){
let ctrlstr.EDC_list -> [list lp] in
  let getEdCtrlListElemByName ctrlstr elt -> [i [n p]] in
  (
    _DELlist list i;
    mutate ctrlstr.EDC_list <- [_ (G2DremoveEdIdxFromList lp i)];
    refreshEdCtrlList ctrlstr;
    let (_GETlistCount list) - 1 -> maxpos in
    let if (i > maxpos) then maxpos else i -> npos in
      _SELlist list npos;
  );
  0;
}


resetEdCtrlList(ctrlstr){
let ctrlstr.EDC_list -> [list lp] in
  (
    _RSTlist list;
    mutate ctrlstr.EDC_list <- [_ nil];
  );
  0;
}


selectEdCtrlList(ctrlstr, name){
let ctrlstr.EDC_list -> [list lp] in
    _SSELlist list name;
  0;
}


selectEdCtrlListByPos(ctrlstr, pos){
let ctrlstr.EDC_list -> [list lp] in
    _SELlist list pos;
  0;
}


selectEdCtrlListByParams(ctrlstr, params){
let ctrlstr.EDC_list -> [list l] in
  let sizelist l -> size in
  let 0 -> i in
  let nil -> ret in
  while i < size && ret == nil do
  (
    let nth_list l i -> elt in
    let elt -> [pos [val p]] in
    let p -> [lp type] in
      if (!strcmpi strcatn lp strcatn params) then
      (
        set ret = pos;
        _SELlist list pos;
      )
      else nil;
    
    set i = i + 1;
  );
  0;
}


getSelectedEdCtrlList(ctrlstr){
let ctrlstr.EDC_list -> [list lp] in
  let _GETlist list -> [pos name] in
  let switch lp pos -> [n [lval type]] in
    [name lval type];
}


setEdCtrlListEnable(ctrlstr, state){
let ctrlstr.EDC_list -> [list lp] in
    _ENlist list state;
  0;
}


cbEdCtrlListDbClick(lst, p, pos, elem){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_list -> [list lp] in
  let switch lp pos -> [n [lval type]] in
    exec cbfun with [ctrlstr pos elem lval type];
  0;
}


setEdCtrlListCbDbClick(ctrlstr, cbfun){
let ctrlstr.EDC_list -> [list lp] in
    _CBlistDclick list @cbEdCtrlListDbClick [ctrlstr cbfun];
  0;
}


cbEdCtrlListClick(lst, p, pos, elem){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_list -> [list lp] in
  let switch lp pos -> [n [lval type]] in
    exec cbfun with [ctrlstr pos elem lval type];
  0;
}


setEdCtrlListCbClick(ctrlstr, cbfun){
let ctrlstr.EDC_list -> [list lp] in
    _CBlistClick list @cbEdCtrlListClick [ctrlstr cbfun];
  0;
}

cbEdCtrlListKeyDown(tree, p, key, code){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_list -> [list lp] in
  let _GETlist list -> [pos name] in
  let switch lp pos -> [n [lval type]] in
  (
    exec cbfun with [ctrlstr pos name lval type key code];
  );
  0;
}


setEdCtrlListCbKeyDown(ctrlstr, cbfun){
let ctrlstr.EDC_list -> [list lp] in
    _CBlistKeyDown list @cbEdCtrlListKeyDown [ctrlstr cbfun];
  0;
}


cbEdCtrlListKeyUp(tree, p, key){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_list -> [list lp] in
  let _GETlist list -> [pos name] in
  let switch lp pos -> [n [lval type]] in
  (
    exec cbfun with [ctrlstr pos name lval type key];
  );
  0;
}


setEdCtrlListCbKeyUp(ctrlstr, cbfun){
let ctrlstr.EDC_list -> [list lp] in
    _CBlistKeyUp list @cbEdCtrlListKeyUp [ctrlstr cbfun];
  0;
}


crEdCtrlList(winstr, x, y, w, h, flags, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRlist ctrlstr.EDC_channel father x y w h (if flags == nil then LB_BORDER|LB_VSCROLL|ET_TABFOCUS else flags) -> list in
  (
    set ctrlstr.EDC_list = [list nil];
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlList(ctrlstr){
let ctrlstr.EDC_list -> [list lp] in
    _DSlist list;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Select combo box
/ ********************************************************************************************* */
fillEdCtrlSelect(ctrlstr, lparam){
_RSTcombo ctrlstr.EDC_select;
  
  let sizelist lparam -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list lparam i -> elt in
    (
      _ADDcombo ctrlstr.EDC_select i elt;
    );
    set i = i + 1;
  );
  
  _SELcombo ctrlstr.EDC_select 0;
  0;
}


addEdCtrlSelect(ctrlstr, param){
_ADDcombo ctrlstr.EDC_select (_GETcomboCount ctrlstr.EDC_select) param;
  0;
}


resetEdCtrlSelect(ctrlstr){
_RSTcombo ctrlstr.EDC_select;
  0;
}


selectEdCtrlSelect(ctrlstr, name){
_SSELcombo ctrlstr.EDC_select name;
  0;
}


selectEdCtrlSelectByPos(ctrlstr, pos){
_SELcombo ctrlstr.EDC_select pos;
  0;
}


getSelectedEdCtrlSelect(ctrlstr){
let _GETcombo ctrlstr.EDC_select -> [pos name] in
    name;
}


getSelectedEdCtrlSelectPos(ctrlstr){
let _GETcombo ctrlstr.EDC_select -> [pos name] in
    pos;
}


setEdCtrlSelectEnable(ctrlstr, state){
_ENcombo ctrlstr.EDC_select state;
  0;
}


cbEdCtrlSelect(sel, p, pos, elem){
let p -> [ctrlstr cbfun] in
    exec cbfun with [ctrlstr pos elem];
  0;
}


setEdCtrlSelectCb(ctrlstr, cbfun){
_CBcombo ctrlstr.EDC_select @cbEdCtrlSelect [ctrlstr cbfun];
  0;
}


crEdCtrlSelect(winstr, x, y, w, h, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRcombo ctrlstr.EDC_channel father x y w h CB_NOEDIT nil -> select in
  (    
    set ctrlstr.EDC_select = select;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlSelect(ctrlstr){
_DScombo ctrlstr.EDC_select;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}
  

/* ********************************************************************************************* /
  Control Tree
/ ********************************************************************************************* */
getEdCtrlTreePreviousSelectedItem(ctrlstr){
let ctrlstr.EDC_tree -> [_ _ _ item _] in item;
}


getEdCtrlTreeSelectedItem(ctrlstr){
let ctrlstr.EDC_tree -> [_ _ item _ _] in item;
}


getEdCtrlTreeFatherItem(ctrlstr, item){
item.EDTITEM_father;
}


getEdCtrlTreeSonsItem(ctrlstr, item){
item.EDTITEM_lSons;
}


isEdCtrlTreeItemSon(ctrlstr, item, father){
let 0 -> ret in
  (
    let sizelist father.EDTITEM_lSons -> size in
    let 0 -> i in
    while i < size && ret != 1 do
    (
      let nth_list father.EDTITEM_lSons i -> elt in
      (
        if elt != item then
          set ret = isEdCtrlTreeItemSon ctrlstr item elt
        else
          set ret = 1;          
      );
      
      set i = i + 1;
    );
    ret;
  );
}


cbEdCtrlTreeSelect(tree, p, item){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] pitem _ _] in
  let switch litems item -> itemstr in
  (
    _SELtreeItem tree item;
    mutate ctrlstr.EDC_tree <- [_ _ itemstr pitem _];
    exec cbfun with [ctrlstr itemstr.EDTITEM_father itemstr itemstr.EDTITEM_sValue itemstr.EDTITEM_iType];
  );
  0;
}


cbEdCtrlTreeDrag(tree, p, item1, item2){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] _ _ _] in
  let switch litems item1 -> item1str in  
  let switch litems item2 -> item2str in  
    exec cbfun with [ctrlstr [item1str.EDTITEM_father item1str item1str.EDTITEM_sValue item1str.EDTITEM_iType] [item2str.EDTITEM_father item2str item2str.EDTITEM_sValue item2str.EDTITEM_iType]];
  0;
}


setEdCtrlTreeCbDrag(ctrlstr, cbfun){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    _CBtreeDrag tree @cbEdCtrlTreeDrag [ctrlstr cbfun];
  0;
}


cbEdCtrlTreeDbClick(tree, p, item, x, y){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] pitem _ _] in
  let switch litems item -> itemstr in
  (
    _SELtreeItem tree item;
    exec cbfun with [ctrlstr itemstr.EDTITEM_father itemstr itemstr.EDTITEM_sValue itemstr.EDTITEM_iType x y];
  );
  0;
}


setEdCtrlTreeCbDbClick(ctrlstr, cbfun){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    _CBtreeDClick tree @cbEdCtrlTreeDbClick [ctrlstr cbfun];
  0;
}


setEdCtrlTreeCbSelect(ctrlstr, cbfun){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
  (
    _CBtreeSelect tree @cbEdCtrlTreeSelect [ctrlstr cbfun];
    mutate ctrlstr.EDC_tree <- [_ _ _ _ cbfun];
  );
  0;
}


cbEdCtrlTreeRclick(tree, p, item, x, y, btn){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] pitem _ cbselfun] in
  let switch litems item -> itemstr in
  (
    _CBtreeSelect tree @cbEdCtrlTreeSelect [ctrlstr nil];
    _SELtreeItem tree item;
    _CBtreeSelect tree @cbEdCtrlTreeSelect [ctrlstr cbselfun];
    
    exec cbfun with [ctrlstr itemstr.EDTITEM_father itemstr itemstr.EDTITEM_sValue itemstr.EDTITEM_iType x y];
  );
  0;
}


setEdCtrlTreeCbRclick(ctrlstr, cbfun){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    _CBtreeRClick tree @cbEdCtrlTreeRclick [ctrlstr cbfun];
  0;
}


cbEdCtrlTreeKeyDown(tree, p, key, code){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] itemstr previtem cbselfun] in
  (
    exec cbfun with [ctrlstr itemstr.EDTITEM_father itemstr itemstr.EDTITEM_sValue itemstr.EDTITEM_iType key code];
  );
  0;
}


setEdCtrlTreeCbKeyDown(ctrlstr, cbfun){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    _CBtreeKeyDown tree @cbEdCtrlTreeKeyDown [ctrlstr cbfun];
  0;
}


cbEdCtrlTreeKeyUp(tree, p, key){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] itemstr _ cbselfun] in
  (
    exec cbfun with [ctrlstr itemstr.EDTITEM_father itemstr itemstr.EDTITEM_sValue itemstr.EDTITEM_iType key];
  );
  0;
}


setEdCtrlTreeCbKeyUp(ctrlstr, cbfun){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    _CBtreeKeyUp tree @cbEdCtrlTreeKeyUp [ctrlstr cbfun];
  0;
}


setEdCtrlTreeExpandAll(ctrlstr, mode){
let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] _ _ _] in
  let sizelist litems -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list litems i -> [item _] in
      _SETtreeItemState tree item mode;
    
    set i = i + 1;
  );
  0;
}


/******************************************
Fonction d'ajout d'un item
*******************************************/
addEdCtrlTreeItem(ctrlstr, father, name, val, type, bitmappath){
let ctrlstr.EDC_tree -> [tree treeparams _ _ _] in
  let treeparams -> [litems lsitems bmplist lbmp] in
  let _ADDtreeChild tree father.EDTITEM_item TREE_INSERT_LAST name -> item in
  
  let switchstri lbmp bitmappath -> bmpidx in
  let if (bitmappath == nil) || (bmpidx != nil) then nil else G2DloadBmp ctrlstr.EDC_channel bitmappath -> bitmap in
  let if bmpidx != nil then bmpidx else if bitmap == nil then nil else let (_ADDbitmapList bmplist bitmap) -> bid in (mutate treeparams <- [_ _ _ [bitmappath bid]::lbmp]; bid;) -> bmpidx in
  let mkEdTreeItem [item name val type father bmpidx nil] -> itemstr in
  (
    if father == nil then nil else
      set father.EDTITEM_lSons = itemstr::father.EDTITEM_lSons;
    
    _SETtreeItemBitmap tree item bmpidx bmpidx;
    
    mutate treeparams <- [([item itemstr]::litems) ([val itemstr]::lsitems) _ _];
    
    itemstr;
  );
}


removeEdCtrlTreeSons(ctrlstr, item){
if item == nil then nil else
  (
    while item.EDTITEM_lSons != nil do
    (
      let hd item.EDTITEM_lSons -> sonstr in
        removeEdCtrlTreeSons ctrlstr sonstr;
      
      set item.EDTITEM_lSons = tl item.EDTITEM_lSons;
    );
    
    let ctrlstr.EDC_tree -> [tree treeparams _ _ _] in
    let treeparams -> [litems lsitems _ _] in
      mutate treeparams <- [(G2DremoveEdIdxFromList litems item.EDTITEM_item) (G2DremoveEdSidFromListi lsitems item.EDTITEM_sValue) _ _];
  );
  0;
}


delEdCtrlTreeItem(ctrlstr, item){
if item == nil then nil else
  let ctrlstr.EDC_tree -> [tree _ _ _ _] in
  (
    removeEdCtrlTreeSons ctrlstr item;
    
    set item.EDTITEM_father.EDTITEM_lSons = G2DremoveFromList item.EDTITEM_father.EDTITEM_lSons item;
    
    _DStreeItem tree item.EDTITEM_item;
  );
  0;
}


refreshEdCtrlTreeSons(ctrlstr, item, sort){
if item == nil then nil else
  let ctrlstr.EDC_tree -> [tree _ _ _ _] in
  let item.EDTITEM_item -> olditem in
  let _ADDtreeChild tree item.EDTITEM_father.EDTITEM_item sort item.EDTITEM_sLabel -> nitem in
  (
    _SETtreeItemBitmap tree nitem item.EDTITEM_bmpIdx item.EDTITEM_bmpIdx;
    set item.EDTITEM_item = nitem;
    
    let ctrlstr.EDC_tree -> [_ treeparams _ _ _] in
    let treeparams -> [litems lsitems _ _] in
      mutate treeparams <- [[item.EDTITEM_item item]::(G2DremoveEdIdxFromList litems olditem) _ _ _];
    
    let item.EDTITEM_lSons -> l in
    while l != nil do
    (
      let hd l -> sonstr in
        refreshEdCtrlTreeSons ctrlstr sonstr TREE_INSERT_FIRST;
      
      set l = tl l;
    );
  );
  0;
}


moveEdCtrlTreeItem(ctrlstr, item, father){
let item.EDTITEM_item -> olditem in
  let item.EDTITEM_father -> oldfather in
  let ctrlstr.EDC_tree -> [tree treeparams _ _ _] in
  let treeparams -> [litems lsitems _ _] in
  (
    set item.EDTITEM_father = father;
    set item.EDTITEM_father.EDTITEM_lSons = item::item.EDTITEM_father.EDTITEM_lSons;
    set oldfather.EDTITEM_lSons = G2DremoveFromList oldfather.EDTITEM_lSons item;
    
    refreshEdCtrlTreeSons ctrlstr item TREE_INSERT_LAST;
    _DStreeItem tree olditem;
  );
  0;
}


sizeEdCtrlTree(ctrlstr, x, y, w, h){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
  (
    _SIZEtree tree w h x y;
  );
}


getEdCtrlTreeItemByValue(ctrlstr, val){
let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] _ _ _] in
    switchstri lsitems val;
}


getEdCtrlTreeValueByItem(ctrlstr, item){
[item.EDTITEM_sValue item.EDTITEM_iType];
}


getEdCtrlTreeFullValuesByItem(ctrlstr, item){
[item.EDTITEM_father item.EDTITEM_sValue item.EDTITEM_iType];
}


getEdCtrlTreeFullValuesByValue(ctrlstr, val){
let getEdCtrlTreeItemByValue ctrlstr val -> item in
    [item.EDTITEM_father item.EDTITEM_sValue item.EDTITEM_iType];
}


getEdCtrlTreeRootItem(ctrlstr){
let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] _ _ _] in
  let nth_list litems ((sizelist litems) -1) -> [_ itemstr] in
    itemstr;
}


getEdCtrlTreeBrothers(ctrlstr, item){
G2DremoveFromList item.EDTITEM_lSons item;
}


selEdCtrlTreeItemByValue(ctrlstr, val){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
  let getEdCtrlTreeItemByValue ctrlstr val -> item in
    _SELtreeItem tree item.EDTITEM_item;
  0;
}


selEdCtrlTreeItem(ctrlstr, item){
let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    _SELtreeItem tree item.EDTITEM_item;
  0;
}


resetEdCtrlTree(ctrlstr){
let ctrlstr.EDC_tree -> [tree treeparams _ _ _] in
  let treeparams -> [litems lsitems bmplist lbmp] in
  (
    let sizelist litems -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list litems i -> [item itemstr] in
        _DStreeItem tree itemstr.EDTITEM_item;
      
      set i = i + 1;
    );
    
    let sizelist lbmp -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lbmp i -> [_ bmpidx] in
        _DELbitmapFromList bmplist bmpidx;
        
      set i = i + 1;
    );
    
    mutate treeparams <- [nil nil _ nil];
    mutate ctrlstr.EDC_tree <- [_ _ nil nil _];
  );
  0;
}


crEdCtrlTree(winstr, x, y, w, h, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRtree ctrlstr.EDC_channel father x y w h TV_BORDER|TV_VSCROLL|TV_HSCROLL|TV_BUTTON -> tree in
  let _CRbitmapList ctrlstr.EDC_channel 16 16 -> bmplist in
  (
    set ctrlstr.EDC_tree = [tree [nil nil bmplist nil] nil nil nil];
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    _SETtreeBitmaps tree bmplist;
    
    _CBtreeDClick tree @cbEdCtrlTreeDbClick [ctrlstr nil];
    _CBtreeSelect tree @cbEdCtrlTreeSelect [ctrlstr nil];
    _CBtreeRClick tree @cbEdCtrlTreeRclick [ctrlstr nil];
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlTree(ctrlstr){
resetEdCtrlTree ctrlstr;
  let ctrlstr.EDC_tree -> [tree [litems lsitems bmplist _] _ _ _] in
  (
    _DStree tree;
    _DSbitmapList bmplist;
  );
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}
  

/* ********************************************************************************************* /
  Control Advanced bitmap list
/ ********************************************************************************************* */
cbEdCtrlBitmapCursorMove(cmpbmp, ctrlstr, x, y, mask){
0;
}


cbEdCtrlBitmapResize(cmpbmp, ctrlstr, w, h){
0;
}


selectEdCtrlBitmapList(ctrlstr, pos){
let ctrlstr.EDC_bitmapList -> [cont marge w h lval _ _] in
  let _CRfont ctrlstr.EDC_channel 10 0 FF_PIXEL "Arial" -> font in  
  (
    let sizelist lval -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lval i -> [epos [bglayer _ _ name _]] in
      (
        if epos == pos then
          G2DsetLayer ctrlstr.EDC_channel bglayer w h 1 0xf3718a 0xff98ab 80
        else
          G2DsetLayer ctrlstr.EDC_channel bglayer w h 0 0xffffff 0xffffff 100;
        
        let _GETalphaBitmaps bglayer -> [tbmp _] in
          _DRAWtext tbmp font (w / 2) h-marge TD_CENTER|TD_BOTTOM 0x000000 name;
      );
      
      set i = i + 1;
    );
    _DSfont font;
    _PAINTcontainer cont;
  );
  0;
}


getEdCtrlBitmapListValbyPos(ctrlstr, pos){
let ctrlstr.EDC_bitmapList -> [_ _ _ _ lval _ _] in
  let switch lval pos -> [_ _ _ _ val] in
    val;
}


cbEdCtrlBitmapListClick(cmpbmp, param, x, y, btn, mask){
let param -> [ctrlstr pos] in
  let ctrlstr.EDC_bitmapList -> [_ _ _ _ lval cbfun _] in
  let switch lval pos -> [_ _ _ _ val] in
  (
    exec cbfun with [ctrlstr val btn mask];
    selectEdCtrlBitmapList ctrlstr pos;
  );
  0;
}


cbEdCtrlBitmapListDbClick(cmpbmp, param, x, y, btn, mask){
let param -> [ctrlstr pos] in
  let ctrlstr.EDC_bitmapList -> [_ _ _ _ lval _ cbfun] in
  let switch lval pos -> [_ _ _ _ val] in
  (
    exec cbfun with [ctrlstr val btn mask];
    selectEdCtrlBitmapList ctrlstr pos;
  );
  0;
}


refreshEdCtrlBitmapListBitmap(ctrlstr){
let ctrlstr.EDC_bitmapList -> [cont marge w h lval _ _] in
  (
    let _GETcontainerPositionSize cont -> [_ _ cw ch] in
    let cw / w -> nbw in
    let sizelist lval -> size in
    let 0 -> i in
    while i < size do
    (
      let (mod i nbw) * w -> lx in
      let (i / nbw) * h -> ly in
      let nth_list lval i -> [epos [_ cbmpback _ _ _]] in
      (
        _CHANGEobjNodeCoordinates (_CONVERTcompBitmapToObjNode cbmpback) [lx ly] 0;      
      );
      
      set i = i + 1;
    );
    _PAINTcontainer cont;
  );
  0;
}


setEdCtrlBitmapListBitmap(ctrlstr, pos, bmppath){
let ctrlstr.EDC_bitmapList -> [cont marge w h lval _ _] in
  let switch lval pos -> [bglayer cbmpback ocbmp name val] in
  (
    _DScompBitmap ocbmp;

    let G2DstrechBitmap ctrlstr.EDC_channel G2DloadBmp ctrlstr.EDC_channel bmppath w-(marge*2) h-(marge*2)-20 0xffffff -> bmp in
    let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
    let _CRcompBitmap ctrlstr.EDC_channel cont (_CONVERTcompBitmapToObjNode cbmpback) [marge marge] OBJ_ENABLE|OBJ_VISIBLE nil abmp 0 0 w h -> cbmp in
    (
      _DSbitmap bmp;
      _CBcompBitmapClick cbmp @cbEdCtrlBitmapListClick [ctrlstr pos];
      _CBcompBitmapDblClick cbmp @cbEdCtrlBitmapListDbClick [ctrlstr pos];
      _CBcompBitmapCursorMove cbmp @cbEdCtrlBitmapCursorMove [ctrlstr pos];
      _CBcompBitmapResize cbmp @cbEdCtrlBitmapResize [ctrlstr pos];     

      mutate ctrlstr.EDC_bitmapList <- [_ _ _ _ (G2Dlcat (G2DremoveEdIdxFromList lval pos) [pos [bglayer cbmpback cbmp name val]]::nil) _ _];
      0;
    );
    
    _PAINTcontainer cont;
  );
  0;
}


setEdCtrlBitmapListCbClick(ctrlstr, cbfun){
mutate ctrlstr.EDC_bitmapList <- [_ _ _ _ _ cbfun _];
  0;
}


setEdCtrlBitmapListCbDbClick(ctrlstr, cbfun){
mutate ctrlstr.EDC_bitmapList <- [_ _ _ _ _ _ cbfun];
  0;
}


addEdCtrlBitmapList(ctrlstr, name, bmppath, val){
let ctrlstr.EDC_bitmapList -> [cont marge w h lval _ _] in
  let sizelist lval -> pos in
  (
    let _GETcontainerPositionSize cont -> [_ _ cw ch] in
    let cw / w -> nbw in
    let (mod pos nbw) * w -> lx in
    let (pos / nbw) * h -> ly in
    let G2DcreateLayer ctrlstr.EDC_channel w h 0 0xffffff 0xffffff 100 -> bglayer in 
    let G2DstrechBitmap ctrlstr.EDC_channel G2DloadBmp ctrlstr.EDC_channel bmppath w-(marge*2) h-(marge*2)-20 0xffffff -> bmp in
    let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
    let _CRcompBitmap ctrlstr.EDC_channel cont nil [lx ly] OBJ_ENABLE|OBJ_VISIBLE nil bglayer 0 0 w h -> cbmpback in
    let _CRcompBitmap ctrlstr.EDC_channel cont (_CONVERTcompBitmapToObjNode cbmpback) [marge marge] OBJ_ENABLE|OBJ_VISIBLE nil abmp 0 0 w h -> cbmp in
    let _GETalphaBitmaps bglayer -> [tbmp _] in
    let _CRfont ctrlstr.EDC_channel 10 0 FF_PIXEL "Arial" -> font in
    (
      _DRAWtext tbmp font (w / 2) h-marge TD_CENTER|TD_BOTTOM 0x000000 name;
      
      _DSfont font;
      
      _DSbitmap bmp;
      _CBcompBitmapClick cbmpback @cbEdCtrlBitmapListClick [ctrlstr pos];
      _CBcompBitmapDblClick cbmpback @cbEdCtrlBitmapListDbClick [ctrlstr pos];
      _CBcompBitmapCursorMove cbmpback @cbEdCtrlBitmapCursorMove [ctrlstr pos];
      _CBcompBitmapResize cbmpback @cbEdCtrlBitmapResize [ctrlstr pos];
      
      _CBcompBitmapClick cbmp @cbEdCtrlBitmapListClick [ctrlstr pos];
      _CBcompBitmapDblClick cbmp @cbEdCtrlBitmapListDbClick [ctrlstr pos];
      _CBcompBitmapCursorMove cbmp @cbEdCtrlBitmapCursorMove [ctrlstr pos];
      _CBcompBitmapResize cbmp @cbEdCtrlBitmapResize [ctrlstr pos];      

      
      mutate ctrlstr.EDC_bitmapList <- [_ _ _ _ (G2Dlcat lval [pos [bglayer cbmpback cbmp name val]]::nil) _ _];
    );
    _PAINTcontainer cont;
    pos;
  );
}


resetEdCtrlBitmapList(ctrlstr){
let ctrlstr.EDC_bitmapList -> [cont marge w h lval _ _] in
  (
    let sizelist lval -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lval i -> [_ [bglayer cbmpback cbmp _ _]] in
      (
        _DScompBitmap cbmpback;
        _DScompBitmap cbmp;
        _DSalphaBitmap bglayer;
      );
      
      set i = i + 1;
    );
    mutate ctrlstr.EDC_bitmapList <- [cont _ _ _ nil _ _];
    _PAINTcontainer cont;
  );
  0;
}


setEdCtrlBitmapListElemSize(ctrlstr, w, h, marge){
mutate ctrlstr.EDC_bitmapList <- [_ marge w h _ _ _];
  0;
}


cbEdCtrlBitmapListSize(cont, ctrlstr, state, w, h){
refreshEdCtrlBitmapListBitmap ctrlstr;
  0;
}

  
crEdCtrlBitmapList(winstr, x, y, w, h, bw, bh, marge, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in  
  let _CRcontainerFromObjWin ctrlstr.EDC_channel father x y w h CO_CHILDINSIDE 0xffffff "" -> cont in
  (
    set ctrlstr.EDC_bitmapList = [cont marge bw bh nil nil nil];
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    _CBcontainerSize cont @cbEdCtrlBitmapListSize ctrlstr;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    _PAINTcontainer cont;
    ctrlstr;
  );
}


dsEdCtrlBitmapList(ctrlstr){
resetEdCtrlBitmapList ctrlstr;
  let ctrlstr.EDC_bitmapList -> [cont _ _ _ _ _ _] in
    _DScontainer cont;
  
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Bitmap
/ ********************************************************************************************* */
cbEdCtrlBitmapResizeResource(cmpbmp, ctrlstr, w, h, oldval){
let oldval -> [ox oy ow oh] in
  let ctrlstr.EDC_bitmap -> [_ obmp _ bmppath bgcolor] in
  
  let if bmppath == nil then (_FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgcolor) else G2DstrechBitmap ctrlstr.EDC_channel G2DloadBmp ctrlstr.EDC_channel bmppath w h 0xffffff -> bmp in
  let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
  (
    _DSbitmap bmp;
    _DSalphaBitmap obmp;
    mutate ctrlstr.EDC_bitmap <- [_ abmp _ _ _];
    [abmp [ox oy w h]]
  );
}
  

cbEdCtrlBitmapResizeGridResource(cmpbmp, p, w, h, oldval){
let p -> [ctrlstr dotcolor dotspace] in
  let oldval -> [ox oy ow oh] in
  let ctrlstr.EDC_bitmap -> [_ obmp _ _ bgcolor] in
  
  let (_FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgcolor) -> bmp in
  let
    // draw dots
    let 0 -> ih in
    while ih <= h do
    (
      let 0 -> iw in
      while iw <= w do
      (
        _PUTpixel24 bmp iw ih dotcolor;
        //_DRAWrectangle gtabstr.PLTAB_buffer iw ih 2 2 DRAW_SOLID 0 0x000000 DRAW_SOLID 0xffffff;
        
        set iw = iw + dotspace;
      );
      
      set ih = ih + dotspace;
    )
  -> _ in  
  let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
  (
    _DSbitmap bmp;
    _DSalphaBitmap obmp;
    mutate ctrlstr.EDC_bitmap <- [_ abmp _ _ _];
    [abmp [ox oy w h]]
  );
}


setEdCtrlBitmap(ctrlstr, bmppath){
let ctrlstr.EDC_bitmap -> [cont alphabmp ocbmp _ _] in
  let _GETcontainerPositionSize cont -> [_ _ w h] in
  (
    _DScompBitmap ocbmp;
    _DSalphaBitmap alphabmp;
    
    let G2DstrechBitmap ctrlstr.EDC_channel G2DloadBmp ctrlstr.EDC_channel bmppath w h 0xffffff -> bmp in
    let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
    let _CRcompBitmap ctrlstr.EDC_channel cont nil [0 0] OBJ_ENABLE|OBJ_VISIBLE nil abmp 0 0 w h -> cbmp in
    (
      _DSbitmap bmp;
      _CBcompBitmapCursorMove cbmp @cbEdCtrlBitmapCursorMove ctrlstr;
      _CBcompBitmapResize cbmp @cbEdCtrlBitmapResize ctrlstr; 
      _CBcompBitmapResizeResource cbmp @cbEdCtrlBitmapResizeResource ctrlstr;
      
      mutate ctrlstr.EDC_bitmap <- [_ abmp cbmp bmppath _];
      0;
    );
    _PAINTcontainer cont;  
  );
  0;
}


getEdCtrlBitmapBuffer(ctrlstr){
let ctrlstr.EDC_bitmap -> [cont alphabmp ocbmp _ _] in
  let _GETalphaBitmaps alphabmp -> [buffer _ ] in
    buffer;
}


setEdCtrlBitmapColor(ctrlstr, bgcolor){
let ctrlstr.EDC_bitmap -> [cont alphabmp ocbmp _ _] in
  let _GETcontainerPositionSize cont -> [_ _ w h] in
  (
    _DScompBitmap ocbmp;
    _DSalphaBitmap alphabmp;
    
    let _FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgcolor -> bmp in
    let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
    let _CRcompBitmap ctrlstr.EDC_channel cont nil [0 0] OBJ_ENABLE|OBJ_VISIBLE nil abmp 0 0 w h -> cbmp in
    (
      _DSbitmap bmp;
      _CBcompBitmapCursorMove cbmp @cbEdCtrlBitmapCursorMove ctrlstr;
      _CBcompBitmapResize cbmp @cbEdCtrlBitmapResize ctrlstr; 
      _CBcompBitmapResizeResource cbmp @cbEdCtrlBitmapResizeResource ctrlstr;
      
      mutate ctrlstr.EDC_bitmap <- [_ abmp cbmp _ bgcolor];
      0;
    );
    _PAINTcontainer cont;  
  );
  0;
}


paintEdCtrlBitmap(ctrlstr){
let ctrlstr.EDC_bitmap -> [cont abmp cbmp bmppath bgcolor] in
    _PAINTcontainer cont;
  0;
}


crEdCtrlBitmap(winstr, x, y, w, h, bmppath, bgcolor, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRcontainerFromObjWin ctrlstr.EDC_channel father x y w h CO_CHILDINSIDE|CO_NOBORDER bgcolor "" -> cont in
  let if bmppath == nil then (_FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgcolor) else G2DstrechBitmap ctrlstr.EDC_channel G2DloadBmp ctrlstr.EDC_channel bmppath w h bgcolor -> bmp in
  let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
  let _CRcompBitmap ctrlstr.EDC_channel cont nil [0 0] OBJ_ENABLE|OBJ_VISIBLE|OBJ_MW_FLEX|OBJ_MH_FLEX OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_CLICK|OBJ_CONTAINER_MOVE abmp 0 0 w h -> cbmp in  
  (
    _DSbitmap bmp;
    _CBcompBitmapCursorMove cbmp @cbEdCtrlBitmapCursorMove ctrlstr;
    _CBcompBitmapResize cbmp @cbEdCtrlBitmapResize ctrlstr;
    _CBcompBitmapResizeResource cbmp @cbEdCtrlBitmapResizeResource ctrlstr;
    
    set ctrlstr.EDC_bitmap = [cont abmp cbmp bmppath bgcolor];
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    _PAINTcontainer cont;
    ctrlstr;
  );
}


crEdCtrlGrid(winstr, x, y, w, h, bgcolor, dotcolor, dotspace, resize){
let if !dotspace then 10 else dotspace -> dotspace in
  let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let _CRcontainerFromObjWin ctrlstr.EDC_channel father x y w h CO_CHILDINSIDE|CO_NOBORDER 0xffffff "" -> cont in
  let _FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgcolor -> bmp in
  let
    // draw dots
    let 0 -> ih in
    while ih <= h do
    (
      let 0 -> iw in
      while iw <= w do
      (
        _PUTpixel24 bmp iw ih dotcolor;
        //_DRAWrectangle gtabstr.PLTAB_buffer iw ih 2 2 DRAW_SOLID 0 0x000000 DRAW_SOLID 0xffffff;
        
        set iw = iw + dotspace;
      );
      
      set ih = ih + dotspace;
    )
  -> _ in
  let _CRalphaBitmap ctrlstr.EDC_channel bmp nil nil nil -> abmp in
  let _CRcompBitmap ctrlstr.EDC_channel cont nil [0 0] OBJ_ENABLE|OBJ_VISIBLE|OBJ_MW_FLEX|OBJ_MH_FLEX OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_CLICK|OBJ_CONTAINER_DBLCLICK|OBJ_CONTAINER_MOVE|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_KEYUP abmp 0 0 w h -> cbmp in  
  (
    _DSbitmap bmp;
    _CBcompBitmapCursorMove cbmp @cbEdCtrlBitmapCursorMove ctrlstr;
    _CBcompBitmapResize cbmp @cbEdCtrlBitmapResize ctrlstr;
    _CBcompBitmapResizeResource cbmp @cbEdCtrlBitmapResizeGridResource [ctrlstr dotcolor dotspace];
    
    set ctrlstr.EDC_bitmap = [cont abmp cbmp nil bgcolor];
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    _PAINTcontainer cont;
    ctrlstr;
  );
}


dsEdCtrlBitmap(ctrlstr){
let ctrlstr.EDC_bitmap -> [cont abmp cbmp bmppath _] in
  (
    _DScompBitmap cbmp;
    _DSalphaBitmap abmp;
    _DScontainer cont;
  );
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control Edit float / Int
/ ********************************************************************************************* */
cbEdCtrlFloatChange(txt, p){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown minval maxval incre nb0 _ _ _ _ _] in
  let _GETtext txt -> val in
  let if ((atof val) == nil) || ((atof val) <. minval) then minval else if ((atof val) >. maxval) then maxval else (atof val) -> fval in  
  (
    if ((atof val) >=. minval) && ((atof val) <=. maxval) && ((atof val) != nil) then nil else
      _SETtext txt G2DgetFtoA fval nb0;
    
    exec cbfun with [ctrlstr fval];
  );
  0;
}


getEdCtrlFloatValue(ctrlstr){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown minval maxval incre nb0 _ _ _ _ _] in
    atof _GETtext txt;
}


setEdCtrlFloatValue(ctrlstr, val){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown minval maxval incre nb0 _ _ _ _ _] in
  let if val == nil then 0.0 else val -> val in
    _SETtext txt G2DgetFtoA val nb0;
  0;
}


setEdCtrlFloatMinValue(ctrlstr, val){
mutate ctrlstr.EDC_editFloat <- [_ _ _ _ val _ _ _ _ _ _ _ _];
}


setEdCtrlFloatMaxValue(ctrlstr, val){
mutate ctrlstr.EDC_editFloat <- [_ _ _ _ _ val _ _ _ _ _ _ _];
}


setEdCtrlFloatValueWithoutCallback(ctrlstr, val){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown minval maxval incre nb0 _ _ _ cbfun _] in
  let if val == nil then 0.0 else val -> val in
  (
    _CBtext txt nil nil;
    _SETtext txt G2DgetFtoA val nb0;
    _CBtext txt @cbEdCtrlFloatChange [ctrlstr cbfun];
  );
  0;
}


setEdCtrlFloatEnable(ctrlstr, state){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ _ _ _ _ _ _ _] in
  let if state then OBJ_ENABLE|OBJ_VISIBLE|ROL_DISABLE|ROL_MASK else OBJ_DISABLE|OBJ_VISIBLE|ROL_DISABLE|ROL_MASK -> flags in  
  (
    _ENtext txt state;
    _CHANGEobjNodeFlags _CONVERTcompRollOverToObjNode cmprup flags 0;
    _CHANGEobjNodeFlags _CONVERTcompRollOverToObjNode cmprdown flags 0;
    _PAINTcontainer cont;
    mutate ctrlstr.EDC_editFloat <- [_ _ _ _ _ _ _ _ _ _ state _ _];
  );
  0;
}


setEdCtrlFloatCbChange(ctrlstr, cbfun){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ _ nb0 _ _ _ _ _] in
    _CBtext txt @cbEdCtrlFloatChange [ctrlstr cbfun];
  
  mutate ctrlstr.EDC_editFloat <- [_ _ _ _ _ _ _ _ _ _ _ cbfun _];
  0;
}


cbEdCtrlFloatValidate(txt, p, val){
let p -> [ctrlstr cbfun] in
  let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown minval maxval _ nb0 _ _ _ _ _] in
  let if ((atof val) <. minval) && minval != nil then
        minval
      else if ((atof val) >. maxval) && maxval != nil then
        maxval
      else
        (atof val)
  -> fval in
  (
    if ((atof val) >=. minval) && ((atof val) <=. maxval) then nil else
      _SETtext txt G2DgetFtoA fval nb0;
    
    exec cbfun with [ctrlstr fval];
  );
  0;
}


setEdCtrlFloatCbValidate(ctrlstr, cbfun){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ _ nb0 _ _ _ _ _] in
    _CBlineOk txt @cbEdCtrlFloatValidate [ctrlstr cbfun];
  
  mutate ctrlstr.EDC_editFloat <- [_ _ _ _ _ _ _ _ _ _ _ _ cbfun];
  0;
}


cbEdCtrlFloatUpClick(cmproll, ctrlstr, x, y, btn, mask){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ incre nb0 _ _ _ _ cbfun] in
  let atof _GETtext txt -> fval in
  (
    _SETtext txt G2DgetFtoA (fval +. incre) nb0;
  
    cbEdCtrlFloatValidate txt [ctrlstr cbfun] G2DgetFtoA (fval +. incre) nb0;
  );
  0;
}


cbEdCtrlFloatDownClick(cmproll, ctrlstr, x, y, btn, mask){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ incre nb0 _ _ _ _ cbfun] in
  let atof _GETtext txt -> fval in
  (
    _SETtext txt G2DgetFtoA (fval -. incre) nb0;
  
    cbEdCtrlFloatValidate txt [ctrlstr cbfun] G2DgetFtoA (fval -. incre) nb0;
  );
  0;
}


cbEdCtrlFloatUnClick(cont, ctrlstr, x, y, btn, mask){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ incre nb0 _ _ _ _ cbfun] in
  let atof _GETtext txt -> fval in
  (
    _SETtext txt G2DgetFtoA fval nb0;
    cbEdCtrlFloatValidate txt [ctrlstr cbfun] G2DgetFtoA fval nb0;
  );
  0;
}


cbEdCtrlFloatLeave(cont, ctrlstr){
_SETcontainerCursor cont nil;
  0;
}


cbEdCtrlFloatDrag(cont, ctrlstr, x, y, mask){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ incre nb0 cy cursor state _ _] in
  if !state then nil else
  let _GETscreenPos -> [sx sy] in
  let _GETscreenSize -> [_ sh] in
  let sh - 40 -> sh in
  (
    let itof (cy - sy) -> coef in
    if (mask & MK_LBUTTON) then
    (
      // TODO move cursor on top or bottom of the screen if sy == 0 || sy == sh
      if (sy <= 1) && (coef >. 0.0) then
      (
        _SETscreenPos sx sh;
        set sy = sh;
      )
      else if (sy >= (sh - 1)) && (coef <. 0.0) then
      (
        _SETscreenPos sx 1;
        set sy = 1;
      )
      else nil;
      
      _SETcontainerCursor cont cursor;
      
      let atof _GETtext txt -> fval in
        setEdCtrlFloatValue ctrlstr (fval +. (incre *. coef));
      
      mutate ctrlstr.EDC_editFloat <- [_ _ _ _ _ _ _ _ sy _ _ _ _];
      0;
    )
    else
    (
      _SETcontainerCursor cont nil;
      mutate ctrlstr.EDC_editFloat <- [_ _ _ _ _ _ _ _ sy _ _ _ _];
      0;
    );
  );
  0;
}


crEdCtrlFloat(winstr, x, y, w, h, value, minval, maxval, incre, nb0, themestr, resize){
let if value == nil then 0.0 else value -> value in
  let if themestr == nil then (if EdDefaultTheme == nil then (set EdDefaultTheme = makeEdThemeResources winstr.EDW_channel) else EdDefaultTheme) else themestr -> themestr in
  
  let mkEdControl [winstr.EDW_channel winstr resize themestr nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let if value == nil then 0.0 else value -> value in
  let _GETalphaBitmapSize themestr.EDT_abmpValUp -> [auw auh] in
  let _GETalphaBitmapSize themestr.EDT_abmpValDown -> [adw adh] in
  let _CReditLine ctrlstr.EDC_channel father x y (w - auw) h if (nb0 == 0 || nb0 == nil) then ET_BORDER|ET_AHSCROLL|ET_TABFOCUS|ET_NUMBER else ET_BORDER|ET_AHSCROLL|ET_TABFOCUS (G2DgetFtoA value nb0) -> txt in
  let _CRcontainerFromObjWin ctrlstr.EDC_channel father (x + (w - auw)) y auw ((auh / 5) + (adh / 5)) CO_CHILDINSIDE|CO_NOBORDER 0xffffff "" -> cont in
  let _CRcompRollOver ctrlstr.EDC_channel cont nil [0 0] OBJ_ENABLE|OBJ_VISIBLE|ROL_MASK|ROL_DISABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK themestr.EDT_abmpValUp -> cmprup in
  let _CRcompRollOver ctrlstr.EDC_channel cont nil [0 (auh / 5)] OBJ_ENABLE|OBJ_VISIBLE|ROL_MASK|ROL_DISABLE OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_DBLCLICK themestr.EDT_abmpValDown -> cmprdown in
  (
    set ctrlstr.EDC_editFloat = [txt cont cmprup cmprdown minval maxval incre nb0 nil themestr.EDT_cursorSize 1 nil nil];
    
    _CBcompRollOverUnClick cmprup @cbEdCtrlFloatUpClick ctrlstr;
    _CBcompRollOverUnClick cmprdown @cbEdCtrlFloatDownClick ctrlstr;

    _CBcontainerCursorMove cont @cbEdCtrlFloatDrag ctrlstr;
    _CBcontainerCursorLeave cont @cbEdCtrlFloatLeave ctrlstr;
    _CBcontainerUnClick cont @cbEdCtrlFloatUnClick ctrlstr;

        
    _CBtext txt @cbEdCtrlFloatChange [ctrlstr nil];
    _CBlineOk txt @cbEdCtrlFloatValidate [ctrlstr nil];
    
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    _PAINTcontainer cont;
    ctrlstr;
  );
}


dsEdCtrlFloat(ctrlstr){
let ctrlstr.EDC_editFloat -> [txt cont cmprup cmprdown _ _ _ _ _ cursor _ _ _] in
  (
    _DStext txt;
    _DScompRollOver cmprup;
    _DScompRollOver cmprdown;
    _DScontainer cont;
  );
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Control 3D
/ ********************************************************************************************* */
crEdCtrl3D(winstr, x, y, w, h, resize){
let mkEdControl [winstr.EDW_channel winstr resize nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let V3DcrView ctrlstr.EDC_channel father x y w h nil nil 1 -> v3dstr in
  (
    set ctrlstr.EDC_view3d = v3dstr;
    
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrl3D(ctrlstr){
V3DdsView ctrlstr.EDC_view3d;
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}
  

/* ********************************************************************************************* /
  Color map
/ ********************************************************************************************* */
proto cbEdColorMapExaValueChange=fun [EdControl S [I I [I I I] EdControl EdControl EdControl EdControl EdControl EdControl EdControl EdControl CompBitmap ObjCursor]] I;
typeof tmrEdColorMapMousePicker=Timer;

fillEdColorMapRuller(ctrlstr, color){
let G2Drgb2hsv color -> [hc sc vc] in
  let ctrlstr.EDC_bitmap -> [cont abmp cbmp bmppath _] in
  let _GETalphaBitmaps abmp -> [bmp _] in
  let _GETbitmapSize bmp -> [_ ymax] in
  let 1.0 /. 100.0 -> delta in
  let 1.0 -> float_1 in
  let 0.0 -> float_0 in
  let itof ymax -> float_max in
  (
    let float_1 -> iv in
    while iv >. float_0 do
    (
      let G2Dhsv2rgb hc sc iv -> c in
        _DRAWrectangle bmp 0 ftoi iv*.float_max 10 3 DRAW_SOLID 2 c DRAW_INVISIBLE nil;
      set iv = iv -. delta;
    );
    _DRAWrectangle bmp 10 0 20 ymax+1 DRAW_INVISIBLE 1 0 DRAW_SOLID 0xffffff;
    
    let (ftoi vc*.float_max) -> av in
    let mktab 3 [10 av] -> t in
    (
      set t.(0) = [20 av-5];
      set t.(2) = [20 av+5];
      _DRAWpoly16 bmp 3 t DRAW_SOLID 1 0 DRAW_SOLID 0;
    );
    
    _PAINTobjNode _CONVERTcompBitmapToObjNode cbmp;
    _PAINTcontainer cont;
  );
  0;
}


cbEdColorMapValueChange(ctrlstr, val, p){
let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross _] in
  let bmpworkstr.EDC_bitmap -> [cont _ _ _ _] in
  let ftoi getEdCtrlFloatValue rtxtstr -> fr in
  let ftoi getEdCtrlFloatValue gtxtstr -> fg in
  let ftoi getEdCtrlFloatValue btxtstr -> fb in
  let ftoi getEdCtrlFloatValue atxtstr -> fa in
  let fr+(fg<<8)+(fb<<16) -> color in
  let _GETcontainerPositionSize cont -> [_ _ w h] in
  let G2Drgb2hsv color -> [hc sc vc] in
  let [(ftoi hc) (ftoi (sc *. 100.0)) (ftoi (vc *. 100.0))] -> [hcolor scolor vcolor] in
  let [hcolor*w/360 scolor*2] -> [crossx crossy] in  
  (
    setEdCtrlEditTextCbChange htxtstr nil;
    
    fillEdColorMapRuller bmprulerstr color;
    setEdCtrlBitmapColor bmpsamplestr color;
    setEdCtrlEditTextValue htxtstr itoh G2Drgb2bgr color;
    
    _CHANGEobjNodeCoordinates _CONVERTcompBitmapToObjNode ccross [crossx-12 crossy-12] 1;  
    
    setEdCtrlEditTextCbChange htxtstr mkfun3 @cbEdColorMapExaValueChange p;
    mutate p <- [(if !mode then color else (G2Drgb2rgba color fa)) _ [hcolor scolor vcolor] _ _ _ _ _ _ _ _ _ _];
  );
  0;
}


cbEdColorMapExaValueChange(ctrlstr, val, p){
let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross _] in
  let G2Drgb2bgr htoi val -> color in
  let G2Drgb2hsv color -> [hc sc vc] in
  let [(ftoi hc) (ftoi (sc *. 100.0)) (ftoi (vc *. 100.0))] -> [hcolor scolor vcolor] in
  let bmpworkstr.EDC_bitmap -> [cont _ _ _ _] in
  let _GETcontainerPositionSize cont -> [_ _ w h] in
  let [hcolor*w/360 scolor*2] -> [crossx crossy] in
  let ftoi getEdCtrlFloatValue atxtstr -> fa in
  (
    setEdCtrlFloatCbChange rtxtstr nil;
    setEdCtrlFloatCbChange gtxtstr nil;
    setEdCtrlFloatCbChange btxtstr nil;
    
    _CHANGEobjNodeCoordinates _CONVERTcompBitmapToObjNode ccross [crossx-12 crossy-12] 1;
    
    setEdCtrlFloatValue rtxtstr itof color&255;
    setEdCtrlFloatValue gtxtstr itof (color>>8)&255;
    setEdCtrlFloatValue btxtstr itof (color>>16)&255;
    
    fillEdColorMapRuller bmprulerstr color;
    setEdCtrlBitmapColor bmpsamplestr color;
    
    setEdCtrlFloatCbChange rtxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlFloatCbChange gtxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlFloatCbChange btxtstr mkfun3 @cbEdColorMapValueChange p;
    
    mutate p <- [(if !mode then color else (G2Drgb2rgba color fa)) _ [hcolor scolor vcolor] _ _ _ _ _ _ _ _ _ _];
  );
  0;
}


cbEdColorMapCrossCursorMove(cont, p, x, y, mask){
if !(mask & MK_LBUTTON) then nil else
  let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross _] in
  let hsvcolor -> [_ _ vcolor] in  
  
  let _GETcontainerPositionSize cont -> [_ _ w h] in
  let if x<=0 then 0 else if x>=w then w else x -> x in
  let if y<=0 then 0 else if y>=h then h else y -> y in
  
  let ftoi getEdCtrlFloatValue atxtstr -> fa in
  let G2Dhsv2rgb (itof x)/.(itof w)*. 360.0 (itof y)/. 200.0 (itof vcolor)/. 100.0 -> color in  
  (
    setEdCtrlFloatCbChange rtxtstr nil;
    setEdCtrlFloatCbChange gtxtstr nil;
    setEdCtrlFloatCbChange btxtstr nil;
    setEdCtrlEditTextCbChange htxtstr nil;
    
    _CHANGEobjNodeCoordinates _CONVERTcompBitmapToObjNode ccross [x-12 y-12] 1;

    setEdCtrlFloatValue rtxtstr itof color&255;      
    setEdCtrlFloatValue gtxtstr itof (color>>8)&255;
    setEdCtrlFloatValue btxtstr itof (color>>16)&255;
    setEdCtrlEditTextValue htxtstr itoh G2Drgb2bgr color;
    
    fillEdColorMapRuller bmprulerstr color;
    setEdCtrlBitmapColor bmpsamplestr color;
    
    setEdCtrlFloatCbChange rtxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlFloatCbChange gtxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlFloatCbChange btxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlEditTextCbChange htxtstr mkfun3 @cbEdColorMapExaValueChange p;
    
    mutate p <- [(if !mode then color else (G2Drgb2rgba color fa)) _ [(x*360/w) y/2 vcolor] _ _ _ _ _ _ _ _ _ _];    
  );
  0;
}


cbEdColorMapCrossCursorClick(cont, p, x, y, btn, mask){
if btn != 1 then nil else
    cbEdColorMapCrossCursorMove cont p x y MK_LBUTTON;
 0;
}


cbEdColorMapRulerCursorMove(cont, p, x, y, mask){
if !(mask & MK_LBUTTON) then nil else
  let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross _] in
  let bmprulerstr.EDC_bitmap -> [_ abmp _ _ _] in
  let hsvcolor -> [hcolor scolor _] in 
  let _GETalphaBitmaps abmp -> [bmp _] in
  let _GETbitmapSize bmp -> [_ ymax] in
  let if y <= 0 then 0 else if y >= ymax then ymax else y -> y in 

  let G2Dhsv2rgb itof hcolor (itof scolor)/. 100.0 (itof y)/.(itof ymax) -> color in
  
  let bmpworkstr.EDC_bitmap -> [contw _ _ _ _] in
  let _GETcontainerPositionSize contw -> [_ _ w h] in
  
  let ftoi getEdCtrlFloatValue atxtstr -> fa in
  let [hcolor*w/360 scolor*2] -> [crossx crossy] in
  (
    setEdCtrlFloatCbChange rtxtstr nil;
    setEdCtrlFloatCbChange gtxtstr nil;
    setEdCtrlFloatCbChange btxtstr nil;
    setEdCtrlEditTextCbChange htxtstr nil;
    
    _CHANGEobjNodeCoordinates _CONVERTcompBitmapToObjNode ccross [crossx-12 crossy-12] 1;
    
    setEdCtrlFloatValue rtxtstr itof color&255;      
    setEdCtrlFloatValue gtxtstr itof (color>>8)&255;
    setEdCtrlFloatValue btxtstr itof (color>>16)&255;
    setEdCtrlEditTextValue htxtstr itoh G2Drgb2bgr color;
    
    fillEdColorMapRuller bmprulerstr color;
    setEdCtrlBitmapColor bmpsamplestr color;
    
    setEdCtrlFloatCbChange rtxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlFloatCbChange gtxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlFloatCbChange btxtstr mkfun3 @cbEdColorMapValueChange p;
    setEdCtrlEditTextCbChange htxtstr mkfun3 @cbEdColorMapExaValueChange p;
    
    mutate p <- [(if !mode then color else (G2Drgb2rgba color fa)) _ [hcolor scolor y*100/ymax] _ _ _ _ _ _ _ _ _ _];    
  );
  0;
}


cbEdColorMapRulerCursorClick(cont, p, x, y, btn, mask){
if btn != 1 then nil else
    cbEdColorMapRulerCursorMove cont p x y MK_LBUTTON;
 0;
}


cbEdColorMapOk(ctrlstr, param){
let param -> [p winstr cbfun] in
  let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross pickcursor] in
  (
    exec cbfun with [ccolor];
    dsEdWindow winstr; 
  );
  0;
}


cbEdColorMapCancel(ctrlstr, param){
let param -> [p winstr cbfun] in
  (
    exec cbfun with [nil];
    dsEdWindow winstr; 
  );
  0;
}


cbEdColorMapScreenPickerTimer(tmr, param){
let param -> [win cont p] in
  let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross pickcursor] in  
  let _GETscreenPos -> [wx wy] in
  (
    _MVwindow win wx-1 wy-1; 

    _SETcontainerCursor cont pickcursor;
  );
  0;
}


cbEdColorMapScreenPickerClick(cont, param, x, y, btn, m){
let param -> [ch win p] in
  let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross pickcursor] in  
  (
    _DSwindow win;
    _DScontainer cont;
    _deltimer tmrEdColorMapMousePicker;
    
    if btn != 1 then nil else
    let _GETscreenPos -> [wx wy] in
    let _CAPTUREscreen (_CRbitmap ch 1 1) wx wy 1 1 0 -> bmp in
    let _GETpixel24 bmp 0 0 -> color in
    let bmpworkstr.EDC_bitmap -> [contw _ _ _ _] in
    let _GETcontainerPositionSize contw -> [_ _ w h] in
    let G2Drgb2hsv color -> [hc sc vc] in
    let [(ftoi hc) (ftoi (sc *. 100.0)) (ftoi (vc *. 100.0))] -> [hcolor scolor vcolor] in
    
    let ftoi getEdCtrlFloatValue atxtstr -> fa in
    let [hcolor*w/360 scolor*2] -> [crossx crossy] in
    (
      setEdCtrlFloatCbChange rtxtstr nil;
      setEdCtrlFloatCbChange gtxtstr nil;
      setEdCtrlFloatCbChange btxtstr nil;
      setEdCtrlEditTextCbChange htxtstr nil;
      
      _CHANGEobjNodeCoordinates _CONVERTcompBitmapToObjNode ccross [crossx-12 crossy-12] 1;
      
      setEdCtrlFloatValue rtxtstr itof color&255;      
      setEdCtrlFloatValue gtxtstr itof (color>>8)&255;
      setEdCtrlFloatValue btxtstr itof (color>>16)&255;
      setEdCtrlEditTextValue htxtstr itoh G2Drgb2bgr color;
      
      fillEdColorMapRuller bmprulerstr color;
      setEdCtrlBitmapColor bmpsamplestr color;
      
      setEdCtrlFloatCbChange rtxtstr mkfun3 @cbEdColorMapValueChange p;
      setEdCtrlFloatCbChange gtxtstr mkfun3 @cbEdColorMapValueChange p;
      setEdCtrlFloatCbChange btxtstr mkfun3 @cbEdColorMapValueChange p;
      setEdCtrlEditTextCbChange htxtstr mkfun3 @cbEdColorMapExaValueChange p;
      
      // INVERT RGB ?
      mutate p <- [(if !mode then color else (G2Drgb2rgba color fa)) _ [hcolor scolor vcolor] _ _ _ _ _ _ _ _ _ _];    
      
      _DSbitmap bmp;
    );
  );
}


cbEdColorMapScreenPicker(tbstr, cmproll, btn, mask, p){
let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross pickcursor] in
  let _GETscreenPos -> [wx wy] in
  let _TOPwindow _CRwindow tbstr.ETB_channel nil wx-1 wy-1 2 2 WN_NOBORDER|WN_NOCAPTION|WN_TRANSPARENCY "" -> capwin in
  let _TOPcontainer _CRcontainerFromObjWin tbstr.ETB_channel capwin 0 0 2 2 CO_NOBORDER|CO_NOCAPTION|CO_CHILDINSIDE nil "" -> newcont in
  (
    _CBcontainerClick newcont @cbEdColorMapScreenPickerClick [tbstr.ETB_channel capwin p];
    _SETcontainerTransparency newcont nil 1 WN_TRANS_ALPHA;
    _SETcontainerCursor newcont pickcursor;
    
    set tmrEdColorMapMousePicker = _rfltimer (_starttimer tbstr.ETB_channel 50) @cbEdColorMapScreenPickerTimer [capwin newcont p];
  );
0;
}


cbEdColorMapDestroy(winstr, p){
let p -> [ccolor mode hsvcolor bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross pickcursor] in
  (
    _DScompBitmap ccross;
  );
  0;
}


crEdColorMap(chan, fatherstr, color, mode, name, themestr, cbfun){
let if themestr == nil then (if EdDefaultTheme == nil then (set EdDefaultTheme = makeEdThemeResources chan) else EdDefaultTheme) else themestr -> themestr in

  let themestr.EDT_abmpColorMapPickerBtn -> abmpcpick in
  let if !mode then color else G2Dbgra2bgr color -> bgrcolor in
  let G2Dgetbgr bgrcolor -> [bc gc rc] in
  let if mode then G2DgetAplhaFromColor color else nil -> alpha in
  
  let [345 330] -> [w h] in
  let _GETscreenSize -> [ww wh] in
  let wh - 40 -> wh in
  let crEdDialogWindow chan fatherstr ((ww / 2) - (w / 2)) ((wh / 2) - (h / 2)) w h WN_MENU nil name -> winstr in
  let crEdCtrlBitmap winstr 10 10 263 200 themestr.EDT_sColorMap nil nil -> bmpworkstr in  
  let crEdCtrlBitmap winstr 10 220 40 40 nil bgrcolor nil -> bmpsamplestr in
  let crEdCtrlBitmap winstr 288 10 20 200 nil bgrcolor nil -> bmprulerstr in
  let crEdCtrlLabel winstr 60 232 15 20 "#" nil -> hlabel in
  let crEdCtrlEditText winstr 75 230 60 20 (itoh bgrcolor) ET_BORDER|ET_TABFOCUS nil -> htxtstr in
  let if !mode then nil else crEdCtrlLabel winstr 145 232 40 20 "Alpha :" nil -> alabel in
  let if !mode then nil else crEdCtrlFloat winstr 190 230 60 20 (itof alpha) 0.0 127.0 1.0 0 themestr nil -> atxtstr in
  let crEdCtrlLabel winstr 10 272 25 20 "R :" nil -> rlabel in
  let crEdCtrlFloat winstr 35 270 60 20 (itof rc) 0.0 255.0 1.0 0 themestr nil -> rtxtstr in
  let crEdCtrlLabel winstr 105 272 25 20 "G :" nil -> glabel in
  let crEdCtrlFloat winstr 130 270 60 20 (itof gc) 0.0 255.0 1.0 0 themestr nil -> gtxtstr in
  let crEdCtrlLabel winstr 200 272 25 20 "B :" nil -> blabel in
  let crEdCtrlFloat winstr 225 270 60 20 (itof bc) 0.0 255.0 1.0 0 themestr nil -> btxtstr in
  let crEdCtrlButton winstr 10 (h - 30) 60 20 "Ok" nil -> okbtnstr in
  let crEdCtrlButton winstr 100 (h - 30) 60 20 "Cancel" nil -> cancelbtnstr in
  let crEdWindowToolBar winstr (w - 34) 268 24 24 0 0 themestr.EDT_iToolBarColor nil -> tbstr in
  
  let bmpworkstr.EDC_bitmap -> [contwork _ cmbpwork _ _] in
  let bmprulerstr.EDC_bitmap -> [contruler _ _ _ _] in
  
  let G2Drgb2hsv bgrcolor -> [hc sc vc] in
  let [(ftoi hc) (ftoi (sc *. 100.0)) (ftoi (vc *. 100.0))] -> [hcolor scolor vcolor] in
  let [hcolor*263/360 scolor*2] -> [crossx crossy] in
  let _CRcompBitmap winstr.EDW_channel contwork (_CONVERTcompBitmapToObjNode cmbpwork)
                    [9 9] OBJ_ENABLE|OBJ_VISIBLE OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_CLICK|OBJ_CONTAINER_MOVE
                    themestr.EDT_abmpColorMapCross 0 0 25 25 -> ccross in
  let [color mode [hcolor scolor vcolor] bmpworkstr bmpsamplestr bmprulerstr htxtstr rtxtstr gtxtstr btxtstr atxtstr ccross themestr.EDT_cursorColorPicker] -> pcolormap in
  let crEdToolBarButton tbstr abmpcpick ETB_ALIGN_LEFT "Pick color" mkfun5 @cbEdColorMapScreenPicker pcolormap -> pickbtnstr in  
  (
    _CHANGEobjNodeCoordinates _CONVERTcompBitmapToObjNode ccross [crossx-12 crossy-12] 1;
    fillEdColorMapRuller bmprulerstr bgrcolor;
    _SETcontainerCursor contwork themestr.EDT_cursorColorPicker;
   
    setEdCtrlFloatCbChange rtxtstr mkfun3 @cbEdColorMapValueChange pcolormap;
    setEdCtrlFloatCbChange gtxtstr mkfun3 @cbEdColorMapValueChange pcolormap;
    setEdCtrlFloatCbChange btxtstr mkfun3 @cbEdColorMapValueChange pcolormap;
    setEdCtrlFloatCbChange atxtstr mkfun3 @cbEdColorMapValueChange pcolormap;
    
    setEdCtrlEditTextCbChange htxtstr mkfun3 @cbEdColorMapExaValueChange pcolormap;
    
    _CBcontainerClick contwork @cbEdColorMapCrossCursorClick pcolormap;
    _CBcontainerCursorMove  contwork @cbEdColorMapCrossCursorMove pcolormap;
    
    _CBcontainerClick contruler @cbEdColorMapRulerCursorClick pcolormap;
    _CBcontainerCursorMove contruler @cbEdColorMapRulerCursorMove pcolormap;
    
    setEdCtrlButtonCb okbtnstr mkfun2 @cbEdColorMapOk [pcolormap winstr cbfun];
    setEdCtrlButtonCb cancelbtnstr mkfun2 @cbEdColorMapCancel [pcolormap winstr cbfun];
    
    paintEdToolBar tbstr;
    _PAINTcontainer contwork;
    _TOPwindow winstr.EDW_win;
    _SETfocus winstr.EDW_win;
    
    setEdwindowCbDestroy winstr mkfun2 @cbEdColorMapDestroy pcolormap;
    winstr;
  );
}


/* ********************************************************************************************* /
  Control Color Button
/ ********************************************************************************************* */
updateEdCtrlColorButton(ctrlstr, color){
if color == nil then nil else
  let ctrlstr.EDC_colorButton -> [btn obmp winstr _ mode cbfun] in
  let _GETbuttonSizePosition btn -> [w h _ _] in
  let if !mode then color else G2Dbgra2bgr color -> bgrcolor in
  let _FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgrcolor -> bmp in
  (
    _DSbitmap obmp;
    _SETbuttonBitmap btn bmp;
    mutate ctrlstr.EDC_colorButton <- [_ bmp _ color _ _];
    _PAINTbutton btn;
  );
  0;
}


cbEdCtrlColorButtonSelect(color, ctrlstr){
let ctrlstr.EDC_colorButton -> [btn obmp winstr ocolor mode cbfun] in
  let if color == nil then ocolor else color -> color in
  (
    updateEdCtrlColorButton ctrlstr color;
    
    mutate ctrlstr.EDC_colorButton <- [_ _ nil color _ _];
    exec cbfun with [ctrlstr color];
  );
  0;
}


getEdCtrlColorButtonColor(ctrlstr){
let ctrlstr.EDC_colorButton -> [btn obmp winstr color mode cbfun] in
    color;
}


cbEdCtrlColorButtonMapDestroy(winstr, ctrlstr){
mutate ctrlstr.EDC_colorButton <- [_ _ nil _ _ _];
  0;
}


cbEdCtrlColorButton(btn, ctrlstr){
let ctrlstr.EDC_colorButton -> [btn obmp winstr color mode cbfun] in
  if winstr != nil then
  (
    _SETfocus winstr.EDW_win;
    0;
  )
  else
  (
    let crEdColorMap ctrlstr.EDC_channel ctrlstr.EDC_father color mode "color selector" ctrlstr.EDC_theme mkfun2 @cbEdCtrlColorButtonSelect ctrlstr -> winstr in
    (
      setEdwindowCbDestroy winstr mkfun2 @cbEdCtrlColorButtonMapDestroy ctrlstr;
      mutate ctrlstr.EDC_colorButton <- [_ _ winstr _ _ _];
    );
    0;
  );
  0;
}


setEdCtrlColorButtonCb(ctrlstr, cbfun){
mutate ctrlstr.EDC_colorButton <- [_ _ _ _ _ cbfun];
  0;
}


crEdCtrlColorButton(winstr, x, y, w, h, color, mode, resize, themestr){
let if themestr == nil then (if EdDefaultTheme == nil then (set EdDefaultTheme = makeEdThemeResources winstr.EDW_channel) else EdDefaultTheme) else themestr -> themestr in

  let mkEdControl [winstr.EDW_channel winstr resize themestr nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  let if !mode then color else G2Drgba2rgb color -> bgrcolor in
  let _FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgrcolor -> bmp in
  let _CRbuttonBitmap ctrlstr.EDC_channel father bmp x y w h PB_TABFOCUS -> button in  
  (
    set ctrlstr.EDC_colorButton = [button bmp nil color mode nil];
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    _CBbutton button @cbEdCtrlColorButton ctrlstr;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [x y (fw-(x + w)) (fh-(y+h)) w h];
    
    ctrlstr;
  );
}


dsEdCtrlColorButton(ctrlstr){
let ctrlstr.EDC_colorButton -> [button bitmap winstr _ _ _] in
  (
    dsEdWindow winstr;
    _DSbitmap bitmap;
    _DSbutton button;
  );
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Modules editor
/ ********************************************************************************************* */

paintEdCtrlModuleEditor(ctrlstr){
let ctrlstr.EDC_modulesEditor.EDM_winScroll -> winstr in
  let _GETwindowPositionSize winstr.EDW_win -> [_ _ ww wh] in
  let _GETwindowPositionSize winstr.EDW_virtualWin -> [vx vy vw vh] in
  if ww <= 0 || wh <= 0 then nil else
    _PAINTcontainerArea ctrlstr.EDC_modulesEditor.EDM_cont (abs vx) (abs vy) ww wh;
  0;
}


findEdCtrlModuleEditorRoundLink(ctrlstr, srcmboxstr, dstmboxstr){
let sizelist ctrlstr.EDC_modulesEditor.EDM_lRoundLinks -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size && ndata == nil do
    (
      let nth_list ctrlstr.EDC_modulesEditor.EDM_lRoundLinks i -> rlinkstr in
      if ((rlinkstr.EDRL_srcModuleBox == srcmboxstr) && (rlinkstr.EDRL_dstModuleBox == dstmboxstr)) || 
         ((rlinkstr.EDRL_dstModuleBox == srcmboxstr) && (rlinkstr.EDRL_srcModuleBox == dstmboxstr))
      then
        set ndata = rlinkstr
      else nil;

      set i = i + 1;
    );
    ndata;
  );
}


calcEdCtrlModuleEditorRoundLinkPos( x1, y1, w1, h1, x2, y2, w2, h2 ){
if (abs (x1 - x2)) > (abs (y1 - y2 ))
  then 
      if x1 < x2 
      then [
             x1+w1 y1+h1/2
             x2-1 y2+h2/2
           ]
      else [
             x1-1 y1+h1/2
             x2+w2 y2+h2/2
           ]
  else if y1 < y2
      then [
             x1+w1/2 y1+h1
             x2+w2/2 y2-1
           ]
      else [
             x1+w1/2 y1-1
             x2+w2/2 y2+h2
           ]
;
}


updateEdCtrlModuleEditorRoundLinkPos(ctrlstr){
let 24 -> dcircle in
  let sizelist ctrlstr.EDC_modulesEditor.EDM_lRoundLinks -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list ctrlstr.EDC_modulesEditor.EDM_lRoundLinks i -> rlinkstr in
    let rlinkstr.EDRL_srcModuleBox.EDB_pos -> [x1 y1] in
    let rlinkstr.EDRL_dstModuleBox.EDB_pos -> [x2 y2] in
    let [rlinkstr.EDRL_srcModuleBox.EDB_iWidth rlinkstr.EDRL_srcModuleBox.EDB_iHeight] -> [w1 h1] in
    let [rlinkstr.EDRL_dstModuleBox.EDB_iWidth rlinkstr.EDRL_dstModuleBox.EDB_iHeight] -> [w2 h2] in
    let if rlinkstr.EDRL_srcModuleBox == rlinkstr.EDRL_dstModuleBox then
        [x1 y1 x2 y2]
        else
          calcEdCtrlModuleEditorRoundLinkPos x1 y1 w1 h1 x2 y2 w2 h2
     -> [px1 py1 px2 py2] in
    let [(((px2 + px1) / 2) - (dcircle / 2)) (((py2 + py1) / 2) - (dcircle / 2))] -> [mx my] in
      _TOPobjNode _CHANGEobjNodeCoordinates rlinkstr.EDRL_node [mx my] 0;

    set i = i + 1;
  );
  0;
}


drawEdCtrlModuleEditorLinkPrivate(buffer, x1, y1, x2, y2, width, color){
_DRAWline
    buffer
    x1 y1
    x2 y2
    DRAW_SOLID
    width
    color;
  0;
}


calcEdCtrlModuleEditorLink(x1, y1, w1, h1, x2, y2, w2, h2){
if (abs (x1 - x2)) > (abs (y1 - y2 ))
  then 
      if x1 < x2 
      then [
             x1+w1 y1+h1/2
             x2-1 y2+h2/2
           ]
      else [
             x1-1 y1+h1/2
             x2+w2 y2+h2/2
           ]
  else if y1 < y2
      then [
             x1+w1/2 y1+h1
             x2+w2/2 y2-1
           ]
      else [
             x1+w1/2 y1-1
             x2+w2/2 y2+h2
           ]
;
}


drawEdCtrlModuleEditorLink(ctrlstr, linkstr){
let linkstr.EDL_srcModuleBox.EDB_pos -> [x1 y1] in
  let [linkstr.EDL_srcModuleBox.EDB_iWidth linkstr.EDL_srcModuleBox.EDB_iHeight] -> [w1 h1] in
  let linkstr.EDL_dstModuleBox.EDB_pos-> [x2 y2] in
  let [linkstr.EDL_dstModuleBox.EDB_iWidth linkstr.EDL_dstModuleBox.EDB_iHeight] -> [w2 h2] in
  
  let if linkstr.EDL_srcModuleBox == linkstr.EDL_dstModuleBox then
        [x1 y1 x2 y2]
      else
        calcEdCtrlModuleEditorLink x1 y1 w1 h1 x2 y2 w2 h2
   -> [px1 py1 px2 py2] in
  
  let ctrlstr.EDC_modulesEditor.EDM_abmpLinks -> alphaBmp in  
  let _GETalphaBitmaps alphaBmp -> [buffer _] in
  let if (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedRoundLink.EDRL_lLinks linkstr) || (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox linkstr.EDL_srcModuleBox) || (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox linkstr.EDL_dstModuleBox) then ctrlstr.EDC_theme.EDT_iModuleEditorLinkOn else ctrlstr.EDC_theme.EDT_iModuleEditorLinkOff -> color in
    drawEdCtrlModuleEditorLinkPrivate buffer px1 py1 px2 py2 ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth color;
  0;
}


refreshEdCtrlModuleEditorLinks(ctrlstr){
let ctrlstr.EDC_modulesEditor -> mestr in
  let ctrlstr.EDC_modulesEditor.EDM_abmpLinks -> alphaBmp in  
  let _GETalphaBitmaps alphaBmp -> [buffer _] in  
  let _GETalphaBitmapTransparency alphaBmp -> transparency in
  (
    // clear links
    _FILLbitmap buffer transparency;  
  
    let sizelist mestr.EDM_lLinks -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_lLinks i -> linkstr in
      let linkstr.EDL_srcModuleBox.EDB_pos -> [x1 y1] in
      let [linkstr.EDL_srcModuleBox.EDB_iWidth linkstr.EDL_srcModuleBox.EDB_iHeight] -> [w1 h1] in
      let linkstr.EDL_dstModuleBox.EDB_pos-> [x2 y2] in
      let [linkstr.EDL_dstModuleBox.EDB_iWidth linkstr.EDL_dstModuleBox.EDB_iHeight] -> [w2 h2] in
      
      let if linkstr.EDL_srcModuleBox == linkstr.EDL_dstModuleBox then
            [x1 y1 x2 y2]
          else
            calcEdCtrlModuleEditorLink x1 y1 w1 h1 x2 y2 w2 h2
       -> [px1 py1 px2 py2] in
      (
        let if (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedRoundLink.EDRL_lLinks linkstr) || (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox linkstr.EDL_srcModuleBox) || (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox linkstr.EDL_dstModuleBox) then ctrlstr.EDC_theme.EDT_iModuleEditorLinkOn else ctrlstr.EDC_theme.EDT_iModuleEditorLinkOff -> color in
          drawEdCtrlModuleEditorLinkPrivate buffer px1 py1 px2 py2 ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth color;
      );
      
      set i = i + 1;
    );
  );
  updateEdCtrlModuleEditorRoundLinkPos ctrlstr;
  paintEdCtrlModuleEditor ctrlstr;
  0;
}


dsEdCtrlModuleEditorRoundLink(ctrlstr, rlinkstr){
if rlinkstr.EDRL_tooltip == nil then nil else
  let rlinkstr.EDRL_tooltip -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set rlinkstr.EDRL_tooltip = nil;
  );
  _DStoolTip rlinkstr.EDRL_node;
  
  _DScompBitmap rlinkstr.EDRL_compBmp;
  _DSalphaBitmap rlinkstr.EDRL_alphaBmp;
  _DSbitmap rlinkstr.EDRL_bmpOn;
  _DSbitmap rlinkstr.EDRL_bmpOff;
  
  exec ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkDestroy with [ctrlstr rlinkstr];
  
  if rlinkstr != ctrlstr.EDC_modulesEditor.EDM_selectedRoundLink then nil else
    set ctrlstr.EDC_modulesEditor.EDM_selectedRoundLink = nil;
  
  set ctrlstr.EDC_modulesEditor.EDM_lRoundLinks = G2DremoveFromList ctrlstr.EDC_modulesEditor.EDM_lRoundLinks rlinkstr;
  0;
}


chkCtrlModuleEditorBox(ctrlstr, mboxstr, add, paint){
let ctrlstr.EDC_modulesEditor -> mestr in
  let if (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox mboxstr) && add then 1 else 0 -> selmode in
  (
    let sizelist mestr.EDM_lBox -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_lBox i -> [_ boxstr] in
      let if (boxstr == mboxstr && !selmode) || ((G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox boxstr) && add && boxstr != mboxstr) then 1 else 0 -> state in
      (
        let _GETalphaBitmaps boxstr.EDB_alphaBmp -> [buffer _] in
        let _GETbitmap (if state then boxstr.EDB_bmpOn else boxstr.EDB_bmpOff) -> sbmp in
          _SETbitmap buffer sbmp;
        
        set boxstr.EDB_bState = state;
        //_PAINTobjNode boxstr.EDB_node;
      );
      
      set i = i + 1;
    );
    
    if (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox mboxstr) && add then
      set ctrlstr.EDC_modulesEditor.EDM_selectedBox = G2DremoveFromList ctrlstr.EDC_modulesEditor.EDM_selectedBox mboxstr
    else if mboxstr == nil then
      set ctrlstr.EDC_modulesEditor.EDM_selectedBox = nil
    else
      set ctrlstr.EDC_modulesEditor.EDM_selectedBox = if add then mboxstr::ctrlstr.EDC_modulesEditor.EDM_selectedBox else mboxstr::nil;
    
    if !paint then nil else
      refreshEdCtrlModuleEditorLinks ctrlstr;
    
    //_PAINTobjNode ctrlstr.EDC_modulesEditor.EDM_node;
    exec mestr.EDM_cbBoxSelect with [ctrlstr mboxstr];
  );
  0;
}


chkCtrlModuleEditorRoundLink(ctrlstr, rlinktr){
let ctrlstr.EDC_modulesEditor -> mestr in
  (
    let sizelist mestr.EDM_lRoundLinks -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_lRoundLinks i -> crlinkstr in
      let if crlinkstr == rlinktr then 1 else 0 -> state in
      (
        let _GETalphaBitmaps crlinkstr.EDRL_alphaBmp -> [buffer _] in
        let _GETbitmap (if state then crlinkstr.EDRL_bmpOn else crlinkstr.EDRL_bmpOff) -> sbmp in
          _SETbitmap buffer sbmp;
        
        set crlinkstr.EDRL_bState = state;
      );
      
      set i = i + 1;
    );
    set ctrlstr.EDC_modulesEditor.EDM_selectedRoundLink = rlinktr;
    refreshEdCtrlModuleEditorLinks ctrlstr;
    //_PAINTobjNode ctrlstr.EDC_modulesEditor.EDM_node;
    //exec mestr.EDM_cbBoxSelect with [ctrlstr mboxstr];
  );
  0;
}


cbEdCtrlModuleEditorRoundLinkClick(cmpbmp, p, x, y, btn, mask){
let p -> [ctrlstr rlinktr] in
  (
    if btn != 1 then nil else
    (
      if ctrlstr.EDC_modulesEditor.EDM_iLinkMode then nil else
      (
        chkCtrlModuleEditorRoundLink ctrlstr rlinktr;
        chkCtrlModuleEditorBox ctrlstr nil 0 1;
      );
      
      _TOPobjNode _PAINTobjNode rlinktr.EDRL_node;
      0;
    );
    exec ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkClick with [ctrlstr rlinktr btn mask];
  );
  0;
}


setEdCtrlModuleEditorRoundLinkCbClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkClick = cbfun;
  0;
}


cbEdCtrlModuleEditorRoundLinkUnClick(cmpbmp, p, x, y, btn, mask){
let p -> [ctrlstr rlinktr] in
    exec ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkUnClick with [ctrlstr rlinktr btn mask];
  0;
}


setEdCtrlModuleEditorRoundLinkCbUnClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkUnClick = cbfun;
  0;
}


cbEdCtrlModuleEditorRoundLinkDbClick(cmpbmp, p, x, y, btn, mask){
let p -> [ctrlstr rlinktr] in
    exec ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkDbClick with [ctrlstr rlinktr btn mask];
  0;
}


setEdCtrlModuleEditorRoundLinkCbDbClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkDbClick = cbfun;
  0;
}


setEdCtrlModuleEditorRoundLinkCbDestroy(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkDestroy = cbfun;
  0;
}


setEdCtrlModuleEditorRoundLinkCbUpdate(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkUpdate = cbfun;
  0;
}


setEdCtrlModuleEditorRoundLinkFlag(rlinkstr, flag){
set rlinkstr.EDRL_iFlag = flag;
}


getEdCtrlModuleEditorRoundLinkFlag(rlinkstr){
rlinkstr.EDRL_iFlag;
}


cbEdModuleEditorRoundLinkToolTipHide(node, p, bubble){
let p -> [ctrlstr rlinkstr] in
  let rlinkstr.EDRL_tooltip -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set rlinkstr.EDRL_tooltip = nil;
  );
  0;
}


cbEdModuleEditorRoundLinkToolTipShow(node, p, bubble, dx, dy){
let p -> [ctrlstr rlinkstr] in
  (
    if rlinkstr.EDRL_tooltip == nil then nil else
    let rlinkstr.EDRL_tooltip -> [tpcont tptext] in
    (
      _DScompText tptext;
      _DScontainer tpcont;
      set rlinkstr.EDRL_tooltip = nil;
    );
    
    let G2DgetStringSize ctrlstr.EDC_theme.EDT_fontToolTip bubble -> [w h] in  
    let _GETscreenSize -> [sw sh] in
    let sh - 40 -> sh in
    let _GETscreenPos -> [sx sy] in
    let [16 16] -> [xdecal ydecal] in
    let if (sx + w + 4 + xdecal) > sw then (sw - (w + 4) - xdecal) else sx + xdecal -> x in
    let if (sy + h + 4 + ydecal) > sh then (sh - (h + 4) - ydecal) else sy + ydecal -> y in
    let (_CRcontainerFromObjWin ctrlstr.EDC_modulesEditor.EDM_channel ctrlstr.EDC_modulesEditor.EDM_winScroll.EDW_virtualWin x y w+4 h+4 CO_NOCAPTION 0xffffff nil) -> tpcont in
    let _CRcompText ctrlstr.EDC_modulesEditor.EDM_channel tpcont nil [2 2] CT_LABEL|CT_LEFT|OBJ_VISIBLE nil w h bubble ctrlstr.EDC_theme.EDT_fontToolTip [0 nil nil nil] nil nil nil -> tptext in
    (
      set rlinkstr.EDRL_tooltip = [tpcont tptext];
      _PAINTcontainer tpcont;
    );
  );
  0;
}


setEdCtrlModuleEditorRoundLinkTooltip(ctrlstr, rlinkstr, bubble){
if rlinkstr.EDRL_tooltip == nil then nil else
  let rlinkstr.EDRL_tooltip -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set rlinkstr.EDRL_tooltip = nil;
  );
  _DStoolTip rlinkstr.EDRL_node;
  _CRtoolTip rlinkstr.EDRL_node 150 bubble @cbEdModuleEditorRoundLinkToolTipShow [ctrlstr rlinkstr] @cbEdModuleEditorRoundLinkToolTipHide [ctrlstr rlinkstr];
  0;
}


crEdCtrlModuleEditorRoundLink(ctrlstr, linkstr){
let ctrlstr.EDC_theme.EDT_iModuleEditorRLinkSize -> dcircle in
  let linkstr.EDL_srcModuleBox -> srcmboxstr in
  let linkstr.EDL_dstModuleBox -> dstmboxstr in
  let findEdCtrlModuleEditorRoundLink ctrlstr srcmboxstr dstmboxstr -> rlinkexiststr in
  let srcmboxstr.EDB_pos -> [x1 y1] in
  let dstmboxstr.EDB_pos -> [x2 y2] in
  let [srcmboxstr.EDB_iWidth srcmboxstr.EDB_iHeight] -> [w1 h1] in
  let [dstmboxstr.EDB_iWidth dstmboxstr.EDB_iHeight] -> [w2 h2] in
  let if srcmboxstr == dstmboxstr then
      [x1 y1 x2 y2]
      else
        calcEdCtrlModuleEditorRoundLinkPos x1 y1 w1 h1 x2 y2 w2 h2
   -> [px1 py1 px2 py2] in
  let [(((px2 + px1) / 2) - (dcircle / 2)) (((py2 + py1) / 2) - (dcircle / 2))] -> [mx my] in
  let if rlinkexiststr != nil then rlinkexiststr else
    (
      let mkEdModuleRoundLink [srcmboxstr dstmboxstr nil nil nil nil nil nil nil nil 0] -> rlinknewstr in
      (
        set ctrlstr.EDC_modulesEditor.EDM_lRoundLinks = G2Dlcat ctrlstr.EDC_modulesEditor.EDM_lRoundLinks rlinknewstr::nil;
        set rlinknewstr.EDRL_bmpOff = _FILLbitmap _CRbitmap ctrlstr.EDC_channel dcircle dcircle 0;
        set rlinknewstr.EDRL_alphaBmp = _CRalphaBitmap ctrlstr.EDC_channel rlinknewstr.EDRL_bmpOff nil nil 0;
        set rlinknewstr.EDRL_compBmp = _CRcompBitmap ctrlstr.EDC_channel ctrlstr.EDC_modulesEditor.EDM_cont ctrlstr.EDC_modulesEditor.EDM_node [mx my] OBJ_ENABLE|OBJ_VISIBLE OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_MOVE rlinknewstr.EDRL_alphaBmp 0 0 dcircle dcircle;
        set rlinknewstr.EDRL_node = _CONVERTcompBitmapToObjNode rlinknewstr.EDRL_compBmp;
        
        _CBcompBitmapClick rlinknewstr.EDRL_compBmp @cbEdCtrlModuleEditorRoundLinkClick [ctrlstr rlinknewstr];
        _CBcompBitmapUnClick rlinknewstr.EDRL_compBmp @cbEdCtrlModuleEditorRoundLinkUnClick [ctrlstr rlinknewstr];
        _CBcompBitmapDblClick rlinknewstr.EDRL_compBmp @cbEdCtrlModuleEditorRoundLinkDbClick [ctrlstr rlinknewstr];
        
        rlinknewstr;
      );
    )
  -> rlinkstr in
  (
    set rlinkstr.EDRL_lLinks = G2Dlcat rlinkstr.EDRL_lLinks linkstr::nil;
    
    if rlinkstr.EDRL_bmpOn == nil then nil else
      _DSbitmap rlinkstr.EDRL_bmpOn;
    
    if rlinkstr.EDRL_bmpOff == nil then nil else
      _DSbitmap rlinkstr.EDRL_bmpOff;
    
    let sizelist rlinkstr.EDRL_lLinks -> nb in
    let _DRAWcircle (_FILLbitmap _CRbitmap ctrlstr.EDC_channel dcircle dcircle 0) (dcircle / 2) (dcircle / 2) (dcircle / 2) DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth ctrlstr.EDC_theme.EDT_iModuleEditorLinkOff DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBoxOff -> offbmp in
    let _DRAWcircle (_FILLbitmap _CRbitmap ctrlstr.EDC_channel dcircle dcircle 0) (dcircle / 2) (dcircle / 2) (dcircle / 2) DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth ctrlstr.EDC_theme.EDT_iModuleEditorLinkOn DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBoxOn -> onbmp in
    
    let _GETstringSize ctrlstr.EDC_theme.EDT_fontModuleEditor itoa nb -> [sw sh] in
    let _DRAWtext offbmp ctrlstr.EDC_theme.EDT_fontModuleEditor (dcircle / 2) ((dcircle / 2) - (sh / 2)) TD_CENTER ctrlstr.EDC_theme.EDT_iModuleEditorBoxTextOff itoa nb -> offbmp in
    let _DRAWtext onbmp ctrlstr.EDC_theme.EDT_fontModuleEditor (dcircle / 2) ((dcircle / 2) - (sh / 2)) TD_CENTER ctrlstr.EDC_theme.EDT_iModuleEditorBoxTextOn itoa nb -> onbmp in
    (
      set rlinkstr.EDRL_bmpOff = offbmp;
      set rlinkstr.EDRL_bmpOn = onbmp;
      
      let _GETalphaBitmaps rlinkstr.EDRL_alphaBmp -> [buffer _] in
      let if rlinkstr.EDRL_bState then _GETbitmap rlinkstr.EDRL_bmpOn else _GETbitmap rlinkstr.EDRL_bmpOff -> sbmp in
        _SETbitmap buffer sbmp;
      
      _CHANGEobjNodeCoordinates rlinkstr.EDRL_node [mx my] 0;
      exec ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkUpdate with [ctrlstr rlinkstr];
    );
  );
  0;
}


getEdCtrlModuleEditorRoundLinkByLink(ctrlstr, linkstr){
let sizelist ctrlstr.EDC_modulesEditor.EDM_lRoundLinks -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size && ndata == nil do
    (
      let nth_list ctrlstr.EDC_modulesEditor.EDM_lRoundLinks i -> rlinkstr in
      let sizelist rlinkstr.EDRL_lLinks -> size2 in
      let 0 -> i2 in
      while i2 < size2 && ndata == nil do
      (
        let nth_list rlinkstr.EDRL_lLinks i2 -> clinkstr in
        if clinkstr != linkstr then nil else
          set ndata = rlinkstr;
        
        set i2 = i2 + 1;
      );
      
      set i = i + 1;
    );
    ndata;
  );
}


removeEdCtrlModuleEditorLinkFromRoundLink(ctrlstr, linkstr, refresh){
let getEdCtrlModuleEditorRoundLinkByLink ctrlstr linkstr -> rlinkstr in
  let ctrlstr.EDC_theme.EDT_iModuleEditorRLinkSize -> dcircle in
  (
    set rlinkstr.EDRL_lLinks = remove_from_list rlinkstr.EDRL_lLinks linkstr;
  
    let sizelist rlinkstr.EDRL_lLinks -> nb in
    if nb <= 0 then
    (
      dsEdCtrlModuleEditorRoundLink ctrlstr rlinkstr;
      if !refresh then nil else
        refreshEdCtrlModuleEditorLinks ctrlstr;
      0;
    )
    else
    (
      if rlinkstr.EDRL_bmpOn == nil then nil else
        _DSbitmap rlinkstr.EDRL_bmpOn;
      
      if rlinkstr.EDRL_bmpOff == nil then nil else
        _DSbitmap rlinkstr.EDRL_bmpOff;
      
      let _DRAWcircle (_FILLbitmap _CRbitmap ctrlstr.EDC_channel dcircle dcircle 0) (dcircle / 2) (dcircle / 2) (dcircle / 2) DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth ctrlstr.EDC_theme.EDT_iModuleEditorLinkOff DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBoxOff -> offbmp in
      let _DRAWcircle (_FILLbitmap _CRbitmap ctrlstr.EDC_channel dcircle dcircle 0) (dcircle / 2) (dcircle / 2) (dcircle / 2) DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth ctrlstr.EDC_theme.EDT_iModuleEditorLinkOn DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBoxOn -> onbmp in
      
      let _GETstringSize ctrlstr.EDC_theme.EDT_fontModuleEditor itoa nb -> [sw sh] in
      let _DRAWtext offbmp ctrlstr.EDC_theme.EDT_fontModuleEditor (dcircle / 2) ((dcircle / 2) - (sh / 2)) TD_CENTER ctrlstr.EDC_theme.EDT_iModuleEditorBoxTextOff itoa nb -> offbmp in
      let _DRAWtext onbmp ctrlstr.EDC_theme.EDT_fontModuleEditor (dcircle / 2) ((dcircle / 2) - (sh / 2)) TD_CENTER ctrlstr.EDC_theme.EDT_iModuleEditorBoxTextOn itoa nb -> onbmp in
      (
        set rlinkstr.EDRL_bmpOff = offbmp;
        set rlinkstr.EDRL_bmpOn = onbmp;
        
        let _GETalphaBitmaps rlinkstr.EDRL_alphaBmp -> [buffer _] in
        let if rlinkstr.EDRL_bState then _GETbitmap rlinkstr.EDRL_bmpOn else _GETbitmap rlinkstr.EDRL_bmpOff -> sbmp in
          _SETbitmap buffer sbmp;
        
        exec ctrlstr.EDC_modulesEditor.EDM_cbRoundLinkUpdate with [ctrlstr rlinkstr];
        _TOPobjNode rlinkstr.EDRL_node;
      );
      0;
    );
  );
  0;
}


dsEdCtrlModuleEditorLink(ctrlstr, linkstr, refresh){
set ctrlstr.EDC_modulesEditor.EDM_lLinks = G2DremoveFromList ctrlstr.EDC_modulesEditor.EDM_lLinks linkstr;
  removeEdCtrlModuleEditorLinkFromRoundLink ctrlstr linkstr refresh;
  0;
}


crEdCtrlModuleEditorLink(ctrlstr, srcmboxstr, dstmboxstr, lp, param){
let mkEdModuleLink [srcmboxstr dstmboxstr lp param 0] -> linkstr in
  (
    set ctrlstr.EDC_modulesEditor.EDM_lLinks = G2Dlcat ctrlstr.EDC_modulesEditor.EDM_lLinks linkstr::nil;
    
    drawEdCtrlModuleEditorLink ctrlstr linkstr;
    crEdCtrlModuleEditorRoundLink ctrlstr linkstr;
    
    // realy slow
    //_PAINTobjNode ctrlstr.EDC_modulesEditor.EDM_node;
    linkstr;
  );
}


getEdCtrlModuleEditorBoxOptimizedPos(mestr, mboxstr, x, y){
let mestr.EDM_sizeSurface -> [surfw surfh] in
  let [mboxstr.EDB_iWidth mboxstr.EDB_iHeight] -> [mcw mch] in
  let sizelist mestr.EDM_lBox -> size in
  let nil -> nx in
  let nil -> ny in
  let 0 -> i in
  (
    while (i < size) && (nx == nil && ny == nil) do
    (
      let nth_list mestr.EDM_lBox i -> [_ boxstr] in
      let boxstr.EDB_pos -> [cx cy] in
      let [boxstr.EDB_iWidth boxstr.EDB_iHeight] -> [cw ch] in
      if boxstr == mboxstr then nil else
      // TODO add box w h in test
      if ((cx != x) || (cy != y)) then nil else
      let if (x + cw + mcw) >= surfw then [x (y + ch)] else [(x + cw) y] -> [xx yy] in
      let getEdCtrlModuleEditorBoxOptimizedPos mestr mboxstr xx yy -> [ntx nty] in
      if (ntx != nil ) && (nty != nil) then
      (
        set nx = ntx;
        set ny = nty;
      )
      else
      (
        set nx = xx;
        set ny = yy;
      );
      
      set i = i + 1;
    );
    [nx ny];
  );
}


cbEdCtrlModuleEditorWheel(cont, ctrlstr, x, y, delta, btn){
let ctrlstr.EDC_modulesEditor.EDM_winScroll -> winstr in
  let ctrlstr.EDC_modulesEditor.EDM_winDmi -> windmistr in
  if winstr.EDW_virtualWin == nil then nil else
  let delta * 10 -> delta in
  /*
  // TODO zoom
  if (btn & MK_CONTROL) then
  let getEdVirtualWindowSize winstr -> [w h] in
  (
    setEdVirtualWindowSize winstr (w-delta) (h-delta);
    setEdWindowSize windmistr (w-delta) (h-delta);
    0;
  )
  else
  */
  (
    let _GETwindowPositionSize winstr.EDW_win -> [_ _ ww wh] in
    let _GETwindowPositionSize winstr.EDW_virtualWin -> [vx vy vw vh] in
    let if (vy + delta) <= (-(vh - wh)) then (-(vh - wh)) else if (vy + delta) >= 0 then 0 else (vy + delta) -> my in
      _MVwindow winstr.EDW_virtualWin vx my;
    0;
  );
  0;
}


setEdCtrlModuleEditorMouseLink(cont, ctrlstr, rec){
let ctrlstr.EDC_modulesEditor -> mestr in
  let mestr.EDM_moveCoords -> [posx posy] in
  let _GETcontainerMap cont -> buffer in
  let mestr.EDM_mnuBox -> selboxstr in
  let selboxstr.EDB_pos -> [x y] in
  let [selboxstr.EDB_iWidth selboxstr.EDB_iHeight] -> [w h] in
  let [(x + (w / 2)) (y + (h / 2))] -> [px py] in
    drawEdCtrlModuleEditorLinkPrivate buffer px py posx posy 1 0xffff00;
  0;
}


cbCtrlModuleEditorCursorMove(cont, ctrlstr, dx, dy, btn){
let ctrlstr.EDC_modulesEditor.EDM_winScroll -> winstr in
  let _GETcursorPos winstr.EDW_win -> [x y] in
  let _GETwindowPositionSize winstr.EDW_win -> [_ _ ww wh] in
  let _GETwindowPositionSize winstr.EDW_virtualWin -> [vx vy vw vh] in
  (
    set ctrlstr.EDC_modulesEditor.EDM_moveCoords = [dx dy];
    
    if (btn & 16) || ((btn == 1) && (ctrlstr.EDC_modulesEditor.EDM_iLinkMode)) then
    if x == nil || y == nil || vx == nil || vy == nil || vw == nil || vh == nil then nil else
    if winstr.EDW_tLastCursorPos == nil then
    (
      set winstr.EDW_tLastCursorPos = [(x - vx) (y - vy)];
      0;
    )
    else
    let winstr.EDW_tLastCursorPos -> [cx cy] in
    let if (x - cx) <= (-(vw - ww)) then (-(vw - ww)) else if (x - cx) >= 0 then 0 else (x - cx) -> mx in
    let if (y - cy) <= (-(vh - wh)) then (-(vh - wh)) else if (y - cy) >= 0 then 0 else (y - cy) -> my in
    (
      _MVwindow winstr.EDW_virtualWin mx my;
      0;
    )
    else nil;
    
    if !ctrlstr.EDC_modulesEditor.EDM_iLinkMode && !btn then nil else
      paintEdCtrlModuleEditor ctrlstr;
  );
  0;
}


calcEdModuleEditorBoxSquare(ctrlstr){
let ctrlstr.EDC_modulesEditor -> mestr in
  let nil -> x in
  let nil -> y in
  let 0 -> w in
  let 0 -> h in
  (
    // first calc the minimum X Y
    let sizelist mestr.EDM_selectedBox -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_selectedBox i -> mboxstr in
      let mboxstr.EDB_pos -> [modx mody] in
      (
        if x == nil || modx < x then
          set x = modx
        else nil;
        if y == nil || mody < y then
          set y = mody
        else nil;
      );
      
      set i = i + 1;
    );
    
    // calc then maximum W H
    let sizelist mestr.EDM_selectedBox -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_selectedBox i -> mboxstr in
      let mboxstr.EDB_pos -> [modx mody] in
      let [mboxstr.EDB_iWidth mboxstr.EDB_iHeight] -> [modw modh] in
      (
        if modw == nil || (modx + modw) > (x + w) then
          set w = (modx - x) + modw
        else nil;
        if modh == nil || (mody + modh) > (y + h) then
          set h = (mody - y) + modh
        else nil;
      );
      
      set i = i + 1;
    );
    [x y w h]
  );
}


cbCtrlModuleEditorBoxCursorMove(cont, p, x, y, btn){
let p -> [ctrlstr smboxstr [cbx cby] [oldx oldy]] in
  let ctrlstr.EDC_modulesEditor -> mestr in
  let _GETwindowPositionSize mestr.EDM_winScroll.EDW_virtualWin -> [cx cy vw vh] in
  let getEdWindowSize mestr.EDM_winScroll -> [ww wh] in
  let calcEdModuleEditorBoxSquare ctrlstr -> [sqx sqy sqw sqh] in
  let mestr.EDM_sizeSurface -> [surfw surfh] in
  let if ((x + cx - (cbx - sqw)) > ww) && ((sqx + sqw) >= surfw) then oldx else x -> x in
  let if ((y + cy - (cby - sqh)) > wh) && ((sqy + sqh) >= surfh) then oldy else y -> y in
  
  let sqx + (x - oldx) -> cnx in
  let sqy + (y - oldy) -> cny in
  let if cnx < 0 then 0 else cnx -> cnx in
  let if cnx > (surfw - sqw) then (surfw - sqw) else cnx -> cnx in
  let if cny < 0 then 0 else cny -> cny in
  let if cny > (surfh - sqh) then (surfh - sqh) else cny -> cny in
  let if x < cbx then 0 else cnx -> cnx in
  let if y < cby then 0 else cny -> cny in
  let [(cnx - sqx) (cny - sqy)] -> [mvx mvy] in
  (
    let sizelist mestr.EDM_selectedBox -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_selectedBox i -> mboxstr in
      let mboxstr.EDB_pos -> [modx mody] in
      let modx + mvx -> nx in
      let mody + mvy -> ny in
      (
        _CHANGEobjNodeCoordinates mboxstr.EDB_node [nx ny] 0;

        set mboxstr.EDB_pos = [nx ny];
        set mboxstr.EDB_bHasMoved = 1;
        
        set i = i + 1;
      );
    );
    
    if ((cnx + cx + sqw) > ww) || ((cnx + cx) < 0) || ((cny + cy + sqh) > wh) || ((cny + cy) < 0) then
    let if ((cnx + cx + sqw) > ww) || ((cnx + cx) < 0) then cx - (cnx - sqx) else cx -> wmvx in
    let if ((cny + cy + sqh) > wh) || ((cny + cy) < 0) then cy - (cny - sqy) else cy -> wmvy in
    let if wmvx <= (-(vw - ww)) then (-(vw - ww)) else if wmvx >= 0 then 0 else wmvx -> wmvx in
    let if wmvy <= (-(vh - wh)) then (-(vh - wh)) else if wmvy >= 0 then 0 else wmvy -> wmvy in
    (
      _MVwindow mestr.EDM_winScroll.EDW_virtualWin wmvx wmvy;
      0;
    )
    else nil;
    
    mutate p <- [_ _ _ [x y]];
    
    refreshEdCtrlModuleEditorLinks ctrlstr;
    0;
  );
  0;
}


cbCtrlModuleEditorUnClick(cont, ctrlstr, x, y, btn, mask){
let ctrlstr.EDC_modulesEditor -> mestr in
  (
    set mestr.EDM_winScroll.EDW_tLastCursorPos = nil;
    _CBcontainerCursorMove mestr.EDM_cont @cbCtrlModuleEditorCursorMove ctrlstr;
    
    let mestr.EDM_selectedBox -> lmboxstr in
    let mestr.EDM_sizeSurface -> [surfw surfh] in
    (
      let sizelist lmboxstr -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list lmboxstr i -> mboxstr in
        if !mboxstr.EDB_bHasMoved then nil else
        let mboxstr.EDB_pos -> [cx cy] in
        let [(cx - (mod cx mestr.EDM_iSnap)) (cy - (mod cy mestr.EDM_iSnap))] -> [nx ny] in
        let getEdCtrlModuleEditorBoxOptimizedPos mestr mboxstr nx ny -> [ntx nty] in
        let [(if ntx == nil then nx else ntx) (if nty == nil then ny else nty)] -> [nx ny] in
        (
          if (nx == cx) && (ny == cy) then nil else
          (
            _CHANGEobjNodeCoordinates mboxstr.EDB_node [nx ny] 0;
            set mboxstr.EDB_pos = [nx ny];
            
            exec mestr.EDM_cbBoxMove with [ctrlstr mboxstr (nx / mestr.EDM_iSnap) (ny / mestr.EDM_iSnap)];
          );
          
          exec mestr.EDM_cbBoxUnClick with [ctrlstr mboxstr btn mask];
          set mboxstr.EDB_bHasMoved = 0;
        );

        set i = i + 1;
      );
    );
  );
  refreshEdCtrlModuleEditorLinks ctrlstr;
  exec ctrlstr.EDC_modulesEditor.EDM_cbUnClick with [ctrlstr x y btn mask];
  0;
}


cbCtrlModuleEditorClick(cont, ctrlstr, x, y, btn, mask){
if (btn != 1) || ctrlstr.EDC_modulesEditor.EDM_iLinkMode then nil else
  (
    chkCtrlModuleEditorBox ctrlstr nil 0 1;
    _CBcontainerCursorMove ctrlstr.EDC_modulesEditor.EDM_cont @cbCtrlModuleEditorCursorMove ctrlstr;
  );
  exec ctrlstr.EDC_modulesEditor.EDM_cbClick with [ctrlstr x y btn mask];
  0;
}
  
  
cbCtrlModuleEditorDbClick(cont, ctrlstr, x, y, btn, mask){
exec ctrlstr.EDC_modulesEditor.EDM_cbDbClick with [ctrlstr x y btn mask];
  0;
}


cbCtrlModuleEditorKeyDown(cont, ctrlstr, key, code){
exec ctrlstr.EDC_modulesEditor.EDM_cbKeyDown with [ctrlstr key code];
  0;
}


cbCtrlModuleEditorKeyUp(cont, ctrlstr, key){
exec ctrlstr.EDC_modulesEditor.EDM_cbKeyUp with [ctrlstr key];
  0;
}


selectCtrlModuleEditorBox(ctrlstr, mboxstr, add){
chkCtrlModuleEditorRoundLink ctrlstr nil;
  chkCtrlModuleEditorBox ctrlstr mboxstr add 1;
  0;
}


cbEdCtrlModuleEditorBoxMenu(elt, p){
let p -> [ctrlstr mboxstr lp] in
  (
    set ctrlstr.EDC_modulesEditor.EDM_mnuBox = mboxstr;
    exec ctrlstr.EDC_modulesEditor.EDM_cbBoxMenu with [ctrlstr mboxstr lp ctrlstr.EDC_modulesEditor.EDM_iLinkInfos];
    set ctrlstr.EDC_modulesEditor.EDM_iLinkInfos = lp;
  );
  0;
}


crEdCtrlModuleEditorBoxMenu(ctrlstr, mboxstr){
let ctrlstr.EDC_modulesEditor -> mestr in
  let _CRpopupMenu mestr.EDM_channel -> mnu in
  let switch mboxstr.EDB_lMenus mestr.EDM_iLinkMode -> l in
  let sizelist l -> size in
  let 0 -> i in
  let nil -> lpp in
  (
    while i < size do
    (
      let nth_list l i -> lp in
      let if mestr.EDM_iBoxMode then switchstr lpp (hd lp) else mnu -> mpop in
      let if mpop == nil then (let _APPpopup mestr.EDM_channel mnu (hd lp) -> mnpop in (set lpp = [(hd lp) mnpop]::lpp; mnpop)) else mpop -> mpop in
      let if mestr.EDM_iBoxMode then (hd tl lp) else (hd lp) -> ename in
        _CBmenu _APPitem mestr.EDM_channel mpop ME_ENABLED ename @cbEdCtrlModuleEditorBoxMenu [ctrlstr mboxstr lp];
      
      set i = i + 1;
    );
    
    mnu;
  );
}


setEdCtrlModuleEditorBoxMenu(ctrlstr, mboxstr, mode, l){
set mboxstr.EDB_lMenus = G2DremoveEdIdxFromList mboxstr.EDB_lMenus mode;
  set mboxstr.EDB_lMenus = G2Dlcat mboxstr.EDB_lMenus [mode l]::nil;
  0;
}


resetEdCtrlModuleEditorBoxMenu(ctrlstr, mboxstr){
set mboxstr.EDB_lMenus = nil;
  0;
}


cbEdModuleEditorBoxToolTipHide(node, p, bubble){
let p -> [ctrlstr mboxstr] in
  let mboxstr.EDB_tooltip -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set mboxstr.EDB_tooltip = nil;
  );
  0;
}


cbEdModuleEditorBoxToolTipShow(node, p, bubble, dx, dy){
let p -> [ctrlstr mboxstr] in
  (
    if mboxstr.EDB_tooltip == nil then nil else
    let mboxstr.EDB_tooltip -> [tpcont tptext] in
    (
      _DScompText tptext;
      _DScontainer tpcont;
      set mboxstr.EDB_tooltip = nil;
    );
    
    let G2DgetStringSize ctrlstr.EDC_theme.EDT_fontToolTip bubble -> [w h] in  
    let _GETscreenSize -> [sw sh] in
    let sh - 40 -> sh in
    let _GETscreenPos -> [sx sy] in
    let [16 16] -> [xdecal ydecal] in
    let if (sx + w + 4 + xdecal) > sw then (sw - (w + 4) - xdecal) else sx + xdecal -> x in
    let if (sy + h + 4 + ydecal) > sh then (sh - (h + 4) - ydecal) else sy + ydecal -> y in
    let (_CRcontainerFromObjWin ctrlstr.EDC_modulesEditor.EDM_channel ctrlstr.EDC_modulesEditor.EDM_winScroll.EDW_virtualWin x y w+4 h+4 CO_NOCAPTION 0xffffff nil) -> tpcont in
    let _CRcompText ctrlstr.EDC_modulesEditor.EDM_channel tpcont nil [2 2] CT_LABEL|CT_CENTER|OBJ_VISIBLE nil w h bubble ctrlstr.EDC_theme.EDT_fontToolTip [0 nil nil nil] nil nil nil -> tptext in
    (
      set mboxstr.EDB_tooltip = [tpcont tptext];
      _PAINTcontainer tpcont;
    );
  );
  0;
}


setEdCtrlModuleEditorBoxTooltip(ctrlstr, mboxstr, bubble){
if mboxstr.EDB_tooltip == nil then nil else
  let mboxstr.EDB_tooltip -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    set mboxstr.EDB_tooltip = nil;
  );
  _DStoolTip mboxstr.EDB_node;
  _CRtoolTip mboxstr.EDB_node 150 bubble @cbEdModuleEditorBoxToolTipShow [ctrlstr mboxstr] @cbEdModuleEditorBoxToolTipHide [ctrlstr mboxstr];
  0;
}


setEdCtrlModuleEditorBoxFlags(mboxstr, flags){
set mboxstr.EDB_iFlags = flags;
}


getEdCtrlModuleEditorBoxFlags(mboxstr){
mboxstr.EDB_iFlags;
}


delEdCtrlModuleEditorBoxMenu(ctrlstr, mboxstr, mode, name, name2){
let ctrlstr.EDC_modulesEditor -> mestr in
  let G2DgetElemFromListByIndex mboxstr.EDB_lMenus mode -> fmenu in
  let fmenu -> [_ lmenu] in
  let if name2 == nil then (remove_all_first_string_from_list lmenu name) else (remove_first_and_second_string_from_list lmenu name name2) -> nl in
    mutate fmenu <- [_ (quicksortList nl @suppDoublon)];
  0;
}


delEdCtrlModuleEditorBoxMenuStartWith(ctrlstr, mboxstr, mode, name){
let ctrlstr.EDC_modulesEditor -> mestr in
  let G2DgetElemFromListByIndex mboxstr.EDB_lMenus mode -> fmenu in
  let fmenu -> [_ lmenu] in
    mutate fmenu <- [_ (quicksortList (remove_first_string_from_list_start_with lmenu name) @suppDoublon)];
  0;
}


addEdCtrlModuleEditorBoxMenu(ctrlstr, mboxstr, mode, lp){
let ctrlstr.EDC_modulesEditor -> mestr in
  let switch mboxstr.EDB_lMenus mode -> lmenu in
  if lmenu == nil then
  (
    setEdCtrlModuleEditorBoxMenu ctrlstr mboxstr mode lp::nil;
    0;
  )
  else // if (isFirstStringInList lmenu (hd lp)) then nil else
  let G2DgetElemFromListByIndex mboxstr.EDB_lMenus mode -> fmenu in
  let fmenu -> [_ lmenu] in
  (
    mutate fmenu <- [_ lp::lmenu];
    0;
  );
  0;
}


sortEdCtrlModuleEditorBoxMenu(ctrlstr, mboxstr){
let ctrlstr.EDC_modulesEditor -> mestr in
  let sizelist mboxstr.EDB_lMenus -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list mboxstr.EDB_lMenus i -> fmenu in
    let fmenu -> [_ lmenu] in
      mutate fmenu <- [_ (quicksortList lmenu @suppDoublon)];
    
    set i = i + 1;
  );
  0;
}


cbEdCtrlModuleEditorBoxClick(cmpbmp, p, x, y, btn, mask){
let p -> [ctrlstr mboxstr] in
  let ctrlstr.EDC_modulesEditor -> mestr in
  if btn == 16 then nil else
  (
    _TOPobjNode _PAINTobjNode mboxstr.EDB_node;
    
    set mboxstr.EDB_bHasMoved = 0;
    set mboxstr.EDB_iKeybState = _keybdstate;
    
    // move
    if btn == 1 && !mestr.EDM_iLinkMode then
    (
      if ((mboxstr.EDB_bState) && (mboxstr.EDB_iKeybState != 2) && ((sizelist ctrlstr.EDC_modulesEditor.EDM_selectedBox) > 1)) then nil else
      (
        chkCtrlModuleEditorRoundLink ctrlstr nil;
        chkCtrlModuleEditorBox ctrlstr mboxstr (if mboxstr.EDB_iKeybState == 2 then 1 else 0) 1;
      );
      
      if mboxstr.EDB_bState then
      let calcEdModuleEditorBoxSquare ctrlstr -> [sqx sqy sqw sqh] in
        _CBcontainerCursorMove mestr.EDM_cont @cbCtrlModuleEditorBoxCursorMove [ctrlstr mboxstr [(x - sqx) (y - sqy)] [x y]]
      else
        _CBcontainerCursorMove mestr.EDM_cont nil nil;
      0;
    )
    else if btn == 2 then
    (
      // menu
      let _GETscreenPos -> [sx sy] in
      let crEdCtrlModuleEditorBoxMenu ctrlstr mboxstr -> mnu in
        _DRAWmenu nil mnu sx sy PM_SCREEN|PM_LEFT_ALIGN|PM_TOP_ALIGN;
      0;
    )
    else
    (
      _CBcontainerCursorMove mestr.EDM_cont nil nil;
      0;
    );
    
    exec mestr.EDM_cbBoxClick with [ctrlstr mboxstr btn mask];
  );
  0;
}


cbEdCtrlModuleEditorBoxDbClick(cmpbmp, p, x, y, btn, mask){
let p -> [ctrlstr mboxstr] in
  if (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox mboxstr) then
    exec ctrlstr.EDC_modulesEditor.EDM_cbBoxDbClick with [ctrlstr mboxstr btn mask]
  else nil;
  0;
}


cbEdCtrlModuleEditorBoxUnClick(cmpbmp, p, x, y, btn, mask){
let p -> [ctrlstr mboxstr] in
  let ctrlstr.EDC_modulesEditor -> mestr in
  (
    if btn == 1 && !mestr.EDM_iLinkMode && !mboxstr.EDB_bHasMoved && ((sizelist ctrlstr.EDC_modulesEditor.EDM_selectedBox) > 1) && (mboxstr.EDB_iKeybState != 2) then
    (
      chkCtrlModuleEditorRoundLink ctrlstr nil;
      chkCtrlModuleEditorBox ctrlstr mboxstr 0 1;
      0;
    )
    else nil;
    set mboxstr.EDB_iKeybState = 0;
    _CBcontainerCursorMove mestr.EDM_cont nil nil;
  );
  0;
}


setEdCtrlModuleEditorBoxPos(ctrlstr, mboxstr, px, py){
let ctrlstr.EDC_modulesEditor -> mestr in
  let px * mestr.EDM_iSnap -> x in
  let py * mestr.EDM_iSnap -> y in
  let getEdCtrlModuleEditorBoxOptimizedPos mestr mboxstr x y -> [ntx nty] in
  let [(if ntx == nil then x else ntx) (if nty == nil then y else nty)] -> [x y] in
  (
    _CHANGEobjNodeCoordinates mboxstr.EDB_node [x y] 0;
    set mboxstr.EDB_pos = [x y];
    
    refreshEdCtrlModuleEditorLinks ctrlstr;
  );
  0;
}


selectEdCtrlModuleEditorBoxes(ctrlstr){
let ctrlstr.EDC_modulesEditor -> mestr in
  let sizelist mestr.EDM_lBox -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list mestr.EDM_lBox i -> [_ mboxstr] in
    if (G2DisInList ctrlstr.EDC_modulesEditor.EDM_selectedBox mboxstr) then nil else
      chkCtrlModuleEditorBox ctrlstr mboxstr 1 0;
      
    set i = i + 1;
  );
  
  paintEdCtrlModuleEditor ctrlstr;
  0;
}


crEdCtrlModuleEditorBox(ctrlstr, name, lp, px, py, icon){
let ctrlstr.EDC_modulesEditor -> mestr in
  let if px == nil then 0 else px -> px in
  let if py == nil then 0 else py -> py in
  let mkEdModuleBox [mestr nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil 0] -> mboxstr in
  let G2DgetStringSize ctrlstr.EDC_theme.EDT_fontModuleEditor name -> [w h] in
  let [(w + 10) (h + 10)] -> [w h] in
  let if w < mestr.EDM_iSnap then mestr.EDM_iSnap else if w > mestr.EDM_iSnap then (mestr.EDM_iSnap * ((w / mestr.EDM_iSnap) + 1)) else w -> w in
  let if h < mestr.EDM_iSnap then mestr.EDM_iSnap else if h > mestr.EDM_iSnap then (mestr.EDM_iSnap * ((h / mestr.EDM_iSnap) + 1)) else h -> h in
  let _DRAWrectangle (_FILLbitmap _CRbitmap ctrlstr.EDC_channel w h ctrlstr.EDC_theme.EDT_iModuleEditorBoxOff) 0 0 w h DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth ctrlstr.EDC_theme.EDT_iModuleEditorBoxBorderOff DRAW_INVISIBLE nil -> bmpoff in
  let _DRAWrectangle (_FILLbitmap _CRbitmap ctrlstr.EDC_channel w h ctrlstr.EDC_theme.EDT_iModuleEditorBoxOn) 0 0 w h DRAW_SOLID ctrlstr.EDC_theme.EDT_iModuleEditorBorderWidth ctrlstr.EDC_theme.EDT_iModuleEditorBoxBorderOn DRAW_INVISIBLE nil -> bmpon in
  let px * mestr.EDM_iSnap -> x in
  let py * mestr.EDM_iSnap -> y in
  let getEdCtrlModuleEditorBoxOptimizedPos mestr mboxstr x y -> [ntx nty] in
  let [(if ntx == nil then x else ntx) (if nty == nil then y else nty)] -> [x y] in
  (
    _DRAWtext bmpoff ctrlstr.EDC_theme.EDT_fontModuleEditor (w / 2) 10 TD_CENTER ctrlstr.EDC_theme.EDT_iModuleEditorBoxTextOff name;
    _DRAWtext bmpon ctrlstr.EDC_theme.EDT_fontModuleEditor (w / 2) 10 TD_CENTER ctrlstr.EDC_theme.EDT_iModuleEditorBoxTextOn name;
    
    set mboxstr.EDB_bmpOff = bmpoff;
    set mboxstr.EDB_bmpOn = bmpon;
    set mboxstr.EDB_sName = name;
    set mboxstr.EDB_lParams = lp;
    set mboxstr.EDB_pos = [x y];
    set mboxstr.EDB_iWidth = w;
    set mboxstr.EDB_iHeight = h;
    set mboxstr.EDB_alphaBmp = _CRalphaBitmap ctrlstr.EDC_channel bmpoff nil nil nil;
    set mboxstr.EDB_compBmp = _CRcompBitmap ctrlstr.EDC_channel mestr.EDM_cont mestr.EDM_node [x y] OBJ_ENABLE|OBJ_VISIBLE OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_MOUSEWHEEL|OBJ_CONTAINER_MOVE mboxstr.EDB_alphaBmp 0 0 w h;
    set mboxstr.EDB_node = _CONVERTcompBitmapToObjNode mboxstr.EDB_compBmp;
    
    exec mestr.EDM_cbBoxMove with [ctrlstr mboxstr (x / mestr.EDM_iSnap) (y / mestr.EDM_iSnap)];
    
    _CBcompBitmapClick mboxstr.EDB_compBmp @cbEdCtrlModuleEditorBoxClick [ctrlstr mboxstr];
    _CBcompBitmapUnClick mboxstr.EDB_compBmp @cbEdCtrlModuleEditorBoxUnClick [ctrlstr mboxstr];
    _CBcompBitmapDblClick mboxstr.EDB_compBmp @cbEdCtrlModuleEditorBoxDbClick [ctrlstr mboxstr];
    
    // too slow
    //_PAINTcontainer mestr.EDM_cont;
    set mestr.EDM_lBox = [name mboxstr]::mestr.EDM_lBox;
    
    mboxstr;
  );
}


getEdCtrlModuleEditorBoxByName(ctrlstr, name){
switchstr ctrlstr.EDC_modulesEditor.EDM_lBox name;
}


getEdCtrlModuleEditorSelectedBox(ctrlstr){
ctrlstr.EDC_modulesEditor.EDM_selectedBox;
}


getEdCtrlModuleEditorSelectedRoundLink(ctrlstr){
ctrlstr.EDC_modulesEditor.EDM_selectedRoundLink;
}


dsEdCtrlModuleEditorBox(ctrlstr, mboxstr){
let ctrlstr.EDC_modulesEditor.EDM_lRoundLinks -> l in
  let sizelist l -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list l i -> rlinkstr in
    if (rlinkstr.EDRL_srcModuleBox != mboxstr) && (rlinkstr.EDRL_dstModuleBox != mboxstr) then nil else
      dsEdCtrlModuleEditorRoundLink ctrlstr rlinkstr;
    
    set i = i + 1;
  );

  let ctrlstr.EDC_modulesEditor.EDM_lLinks -> l in
  let sizelist l -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list l i -> linkstr in
    if (linkstr.EDL_srcModuleBox != mboxstr) && (linkstr.EDL_dstModuleBox != mboxstr) then nil else
      dsEdCtrlModuleEditorLink ctrlstr linkstr 0;
    
    set i = i + 1;
  );
 
  set ctrlstr.EDC_modulesEditor.EDM_selectedBox = G2DremoveFromList ctrlstr.EDC_modulesEditor.EDM_selectedBox mboxstr;
  
  let mboxstr.EDB_tooltip -> [tpcont tptext] in
  (
    _DScompText tptext;
    _DScontainer tpcont;
    _DStoolTip mboxstr.EDB_node;
    set mboxstr.EDB_tooltip = nil;
  );
  
  _DScompBitmap mboxstr.EDB_compBmp;
  _DSalphaBitmap mboxstr.EDB_alphaBmp;
  _DSbitmap mboxstr.EDB_bmpOn;
  _DSbitmap mboxstr.EDB_bmpOn;
  
  set ctrlstr.EDC_modulesEditor.EDM_lBox = G2DremoveEdSidFromList ctrlstr.EDC_modulesEditor.EDM_lBox mboxstr.EDB_sName;
  
  //refreshEdCtrlModuleEditorLinks ctrlstr;
  
  //_PAINTcontainer ctrlstr.EDC_modulesEditor.EDM_cont;
  0;
}


setEdCtrlModuleEditorLinkMode(ctrlstr, mode){
set ctrlstr.EDC_modulesEditor.EDM_iLinkMode = mode;
  
  if mode then
  (
    _CBcontainerPostRender ctrlstr.EDC_modulesEditor.EDM_cont @setEdCtrlModuleEditorMouseLink ctrlstr;
    0;
  )
  else
  (
    _CBcontainerPostRender ctrlstr.EDC_modulesEditor.EDM_cont nil nil;
     paintEdCtrlModuleEditor ctrlstr;
    0;
  );
  0;
}


getEdCtrlModuleEditorLinkMode(ctrlstr){
ctrlstr.EDC_modulesEditor.EDM_iLinkMode;
}


resetEdCtrlModuleEditor(ctrlstr){
set ctrlstr.EDC_modulesEditor.EDM_selectedBox = nil;
  let ctrlstr.EDC_modulesEditor -> mestr in
  (
    let sizelist mestr.EDM_lBox -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list mestr.EDM_lBox i -> [_ mboxstr] in
      let mboxstr.EDB_tooltip -> [tpcont tptext] in
      (
        _DScompText tptext;
        _DScontainer tpcont;
        _DStoolTip mboxstr.EDB_node;
        set mboxstr.EDB_tooltip = nil;

        _DScompBitmap mboxstr.EDB_compBmp;
        _DSalphaBitmap mboxstr.EDB_alphaBmp;
        _DSbitmap mboxstr.EDB_bmpOn;
        _DSbitmap mboxstr.EDB_bmpOff;
      );
      
      set i = i + 1;
    );
    set mestr.EDM_lBox = nil;
    
    let mestr.EDM_lRoundLinks -> l in
    let sizelist l -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list l i -> rlinkstr in
        dsEdCtrlModuleEditorRoundLink ctrlstr rlinkstr;
      
      set i = i + 1;
    );
    
    set mestr.EDM_lLinks = nil;
    refreshEdCtrlModuleEditorLinks ctrlstr;
  );
  0;
}


setEdCtrlModuleEditorCbBoxMenu(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbBoxMenu = cbfun;
  0;
}


setEdCtrlModuleEditorCbBoxSelect(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbBoxSelect = cbfun;
  0;
}


setEdCtrlModuleEditorCbBoxClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbBoxClick = cbfun;
  0;
}


setEdCtrlModuleEditorCbBoxUnClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbBoxUnClick = cbfun;
  0;
}


setEdCtrlModuleEditorCbBoxDbClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbBoxDbClick = cbfun;
  0;
}


setEdCtrlModuleEditorCbBoxMove(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbBoxMove = cbfun;
  0;
}


setEdCtrlModuleEditorCbClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbClick = cbfun;
  0;
}


setEdCtrlModuleEditorCbUnClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbUnClick = cbfun;
  0;
}


setEdCtrlModuleEditorCbDbClick(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbDbClick = cbfun;
  0;
}


setEdCtrlModuleEditorCbKeyDown(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbKeyDown = cbfun;
  0;
}


setEdCtrlModuleEditorCbKeyUp(ctrlstr, cbfun){
set ctrlstr.EDC_modulesEditor.EDM_cbKeyUp = cbfun;
  0;
}


cbEdCtrlModuleEditorSize(winstr, w, h, ctrlstr){
paintEdCtrlModuleEditor ctrlstr;
  0;
}


cbEdCtrlModuleEditorScroll(winstr, x, y, ctrlstr){
paintEdCtrlModuleEditor ctrlstr;
  0;
}


crEdCtrlModuleEditor(winstr, surfw, surfh, snap, mode, themestr){
let if themestr == nil then (if EdDefaultTheme == nil then (set EdDefaultTheme = makeEdThemeResources winstr.EDW_channel) else EdDefaultTheme) else themestr -> themestr in
  let getEdWindowSize winstr -> [w h] in
  let mkEdControl [winstr.EDW_channel winstr nil themestr nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> ctrlstr in
  let if ctrlstr.EDC_father.EDW_virtualWin == nil then ctrlstr.EDC_father.EDW_win else ctrlstr.EDC_father.EDW_virtualWin -> father in
  
  let crEdScrollWindow ctrlstr.EDC_channel winstr 0 0 w h WN_CHILDINSIDE|WN_VSCROLL|WN_HSCROLL EDWIN_RESIZE_MW|EDWIN_RESIZE_MH nil "" -> scrollwinstr in
  let crEdWindow ctrlstr.EDC_channel scrollwinstr 0 0 surfw surfh WN_NOBORDER|WN_CHILDINSIDE nil nil "" -> windmistr in
  let crEdCtrlGrid windmistr 0 0 surfw surfh themestr.EDT_iModuleEditorBg themestr.EDT_iModuleEditorDot snap nil -> ctrlbmp in
  let ctrlbmp.EDC_bitmap -> [cont _ bgcomp _ _] in
  let _CRalphaBitmap ctrlstr.EDC_channel _CRbitmap ctrlstr.EDC_channel surfw surfh nil 0x000000 0x000000 -> abmplinks in
  let _CRcompBitmap ctrlstr.EDC_channel cont (_CONVERTcompBitmapToObjNode bgcomp) [0 0] OBJ_VISIBLE|OBJ_ENABLE OBJ_CONTAINER_CLICK|OBJ_CONTAINER_UNCLICK|OBJ_CONTAINER_MOVE|OBJ_CONTAINER_KEYDOWN|OBJ_CONTAINER_KEYUP|OBJ_CONTAINER_DBLCLICK abmplinks 0 0 surfw surfh -> cmplinks in
  
  let mkEdModuleEditor [ctrlstr.EDC_channel nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> mestr in
  (
    setEdwindowCbSize scrollwinstr mkfun4 @cbEdCtrlModuleEditorSize ctrlstr;
    setEdwindowCbVirtualMove scrollwinstr mkfun4 @cbEdCtrlModuleEditorScroll ctrlstr;
    
    set mestr.EDM_winScroll = scrollwinstr;
    set mestr.EDM_winDmi = windmistr;
    set mestr.EDM_bmpBack = ctrlbmp;
    set mestr.EDM_abmpLinks = abmplinks;
    set mestr.EDM_bmpLinks = cmplinks;
    set mestr.EDM_sizeSurface = [surfw surfh];
    set mestr.EDM_iLinkMode = 0;
    set mestr.EDM_iBoxMode = mode;
    
    set mestr.EDM_node = _CONVERTcompBitmapToObjNode cmplinks;
    set mestr.EDM_cont = cont;
    set mestr.EDM_iSnap = snap;
    
    _CBcontainerMouseWheel mestr.EDM_cont @cbEdCtrlModuleEditorWheel ctrlstr;
    _CBcontainerCursorMove mestr.EDM_cont @cbCtrlModuleEditorCursorMove ctrlstr;
    _CBcontainerClick mestr.EDM_cont @cbCtrlModuleEditorClick ctrlstr;
    _CBcontainerDblClick mestr.EDM_cont @cbCtrlModuleEditorDbClick ctrlstr;
    _CBcontainerUnClick mestr.EDM_cont @cbCtrlModuleEditorUnClick ctrlstr;
    _CBcontainerKeyDown mestr.EDM_cont @cbCtrlModuleEditorKeyDown ctrlstr;
    _CBcontainerKeyUp mestr.EDM_cont @cbCtrlModuleEditorKeyUp ctrlstr;
    
    set ctrlstr.EDC_modulesEditor = mestr;
    set winstr.EDW_lControl = ctrlstr::winstr.EDW_lControl;
    
    let _GETwindowPositionSize father -> [_ _ fw fh] in
      set ctrlstr.EDC_coords = [0 0 (fw-w) (fh-h) w h];
    
    ctrlstr;
  );
}


dsEdCtrlModuleEditor(ctrlstr){
resetEdCtrlModuleEditor ctrlstr;
  
  let ctrlstr.EDC_modulesEditor -> mestr in
  (
    dsEdWindow mestr.EDM_winScroll;
    dsEdWindow mestr.EDM_winDmi;
    dsEdCtrlBitmap mestr.EDM_bmpBack;
    _DScompBitmap mestr.EDM_bmpLinks;
    _DSalphaBitmap mestr.EDM_abmpLinks;
  );
  set ctrlstr.EDC_father.EDW_lControl = G2DremoveFromList ctrlstr.EDC_father.EDW_lControl ctrlstr;
  0;
}


/* ********************************************************************************************* /
  Controls common
/ ********************************************************************************************* */
dsEdWindowCtrlList(lctrl){
let sizelist lctrl -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list lctrl i -> ctrl in
    (
      if ctrl.EDC_label == nil then nil else
        dsEdCtrlLabel ctrl;

      if ctrl.EDC_text == nil then nil else
        dsEdCtrlText ctrl;    

      if ctrl.EDC_editText == nil then nil else
        dsEdCtrlEditText ctrl;    

      if ctrl.EDC_editLine == nil then nil else
        dsEdCtrlTextLine ctrl;

      if ctrl.EDC_editFloat == nil then nil else
        dsEdCtrlFloat ctrl;

      if ctrl.EDC_button == nil then nil else
        dsEdCtrlButton ctrl;

      if ctrl.EDC_colorButton == nil then nil else
        dsEdCtrlColorButton ctrl;
              
      if ctrl.EDC_check == nil then nil else
        dsEdCtrlCheck ctrl;
      
      if ctrl.EDC_list == nil then nil else
        dsEdCtrlList ctrl;
        
      if ctrl.EDC_tree == nil then nil else
        dsEdCtrlTree ctrl;
        
      if ctrl.EDC_bitmap == nil then nil else
        dsEdCtrlBitmap ctrl;
        
      if ctrl.EDC_select == nil then nil else
        dsEdCtrlSelect ctrl;
        
      if ctrl.EDC_bitmapList == nil then nil else
        dsEdCtrlBitmapList ctrl;
      
      if ctrl.EDC_view3d == nil then nil else
        dsEdCtrl3D ctrl;      
      
      if ctrl.EDC_modulesEditor == nil then nil else
        dsEdCtrlModuleEditor ctrl;
    );
  
    set i = i + 1;
  );
  0;
}


setEdCtrlSize(ctrlstr, w, h){
let getEdWindowSize ctrlstr.EDC_father -> [fw fh] in
  // + 1 because of the border size
  (
    if ctrlstr.EDC_label != nil then
    let _GETtextPositionSize ctrlstr.EDC_label -> [x y _ _] in 
    (
      _POSITIONtext ctrlstr.EDC_label x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_editText != nil then    
    let _GETtextPositionSize ctrlstr.EDC_editText -> [x y _ _] in 
    (
      _POSITIONtext ctrlstr.EDC_editText x y w+1 h+1;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_editLine != nil then
    let _GETtextPositionSize ctrlstr.EDC_editLine -> [x y _ _] in
    (
      _POSITIONtext ctrlstr.EDC_editLine x y w+1 h+1;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_text != nil then   
    let _GETtextPositionSize ctrlstr.EDC_text -> [x y _ _] in
    (
      _POSITIONtext ctrlstr.EDC_text x y w+1 h+1;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_button != nil then
    let _GETbuttonPositionSize ctrlstr.EDC_button -> [x y _ _] in
    (
      _POSITIONbutton ctrlstr.EDC_button x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_check != nil then
    let _GETcheckPositionSize ctrlstr.EDC_check -> [x y _ _] in
    (
      _POSITIONcheck ctrlstr.EDC_check x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_list != nil then
    let ctrlstr.EDC_list -> [list lp] in
    let _GETlistPositionSize list -> [x y _ _] in
    (
      _POSITIONlist list x y w+1 h+1;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_select != nil then
    let _GETcomboPositionSize ctrlstr.EDC_select -> [x y _ _] in
    (
      _POSITIONcombo ctrlstr.EDC_select x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_tree != nil then
    let ctrlstr.EDC_tree -> [tree _ _ _ _] in
    let _GETtreePositionSize tree -> [x y _ _] in    
    (
      _POSITIONtree tree x y w+1 h+1;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_bitmap != nil then
    let ctrlstr.EDC_bitmap -> [cont alphabmp ocbmp _ _] in
    let _GETcontainerPositionSize cont -> [x y _ _] in    
    (
      _SIZEcontainer cont x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_bitmapList != nil then
    let ctrlstr.EDC_bitmapList -> [cont _ _ _ _ _ _] in
    let _GETcontainerPositionSize cont -> [x y _ _] in    
    (
      _SIZEcontainer cont x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_editFloat != nil then
    let ctrlstr.EDC_editFloat -> [txt cont _ _ _ _ _ _ _ _ _ _ _] in
    let _GETcontainerExPositionSize cont -> [_ _ bw bh] in
    let _GETtextPositionSize txt -> [x y _ _] in      
    (
      _POSITIONtext txt x y ((w - bw) + 1) (h + 1);
      _MOVEcontainer cont (x + (w - bw)) y;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_view3d != nil then
    let V3DgetViewPos ctrlstr.EDC_view3d -> [x y] in    
    (
      V3DresizeView ctrlstr.EDC_view3d x y w h;
      mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      0;
    )
    else if ctrlstr.EDC_colorButton != nil then
    let ctrlstr.EDC_colorButton -> [btn obmp winstr color mode cbfun] in
    let _GETbuttonPositionSize btn -> [x y _ _] in 
    (
      let if !mode then (G2Drgb2bgr color) else G2Dbgra2bgr (G2Drgba2bgra color) -> bgrcolor in
      let _FILLbitmap _CRbitmap ctrlstr.EDC_channel w h bgrcolor -> bmp in
      (
        _DSbitmap obmp;
        _POSITIONbutton btn x y w h;
        _SETbuttonBitmap btn bmp;
        mutate ctrlstr.EDC_colorButton <- [_ bmp _ color _ _];
        _PAINTbutton btn;
        
        mutate ctrlstr.EDC_coords <- [x y (fw-(x + w)) (fh-(y+h)) w h];
      );
      0;
    )
    else nil;
  );
  0;
}
// -- [/filterPKG] --

---