Browse Source

AROS: syscall-ified ASL, GadTools and MUI from AROS branch

git-svn-id: trunk@28646 -
marcus 11 years ago
parent
commit
4c3e25549d

+ 3 - 0
.gitattributes

@@ -1129,9 +1129,11 @@ packages/arosunits/Makefile.fpc.fpcmake svneol=native#text/plain
 packages/arosunits/fpmake.pp svneol=native#text/plain
 packages/arosunits/src/agraphics.pas svneol=native#text/plain
 packages/arosunits/src/amigados.pas svneol=native#text/plain
+packages/arosunits/src/asl.pas svneol=native#text/plain
 packages/arosunits/src/clipboard.pas svneol=native#text/plain
 packages/arosunits/src/diskfont.pas svneol=native#text/plain
 packages/arosunits/src/exec.pas svneol=native#text/plain
+packages/arosunits/src/gadtools.pas svneol=native#text/plain
 packages/arosunits/src/hardware.pas svneol=native#text/plain
 packages/arosunits/src/icon.pas svneol=native#text/plain
 packages/arosunits/src/iffparse.pas svneol=native#text/plain
@@ -1140,6 +1142,7 @@ packages/arosunits/src/intuition.pas svneol=native#text/plain
 packages/arosunits/src/keymap.pas svneol=native#text/plain
 packages/arosunits/src/layers.pas svneol=native#text/plain
 packages/arosunits/src/longarray.pas svneol=native#text/plain
+packages/arosunits/src/mui.pas svneol=native#text/plain
 packages/arosunits/src/tagsarray.pas svneol=native#text/plain
 packages/arosunits/src/timer.pas svneol=native#text/plain
 packages/arosunits/src/utility.pas svneol=native#text/plain

+ 1 - 1
packages/arosunits/Makefile.fpc.fpcmake

@@ -9,7 +9,7 @@ version=2.7.1
 [target]
 units= agraphics amigados exec hardware inputevent intuition keymap layers \
        longarray tagsarray timer utility diskfont iffparse clipboard       \
-       workbench icon
+       workbench icon gadtools asl mui
 
 [compiler]
 includedir=src

+ 3 - 0
packages/arosunits/fpmake.pp

@@ -48,6 +48,9 @@ begin
     T:=P.Targets.AddUnit('clipboard.pas');
     T:=P.Targets.AddUnit('workbench.pas');
     T:=P.Targets.AddUnit('icon.pas');
+    T:=P.Targets.AddUnit('gadtools.pas');
+    T:=P.Targets.AddUnit('asl.pas');
+    T:=P.Targets.AddUnit('mui.pas');
 
 {$ifndef ALLPACKAGES}
     Run;

+ 555 - 0
packages/arosunits/src/asl.pas

@@ -0,0 +1,555 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2014 by Free Pascal development team
+
+    asl.library functions
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+
+unit asl;
+
+{$mode objfpc}
+
+interface
+
+uses
+  exec, utility, workbench, agraphics, tagsarray;
+
+{************************************************************************}
+
+CONST
+  ASLNAME: PChar = 'asl.library';
+  ASL_TB         = TAG_USER+$80000;
+
+{************************************************************************}
+
+{ Types of requesters known to ASL, used as arguments to AllocAslRequest() }
+  ASL_FileRequest       = 0;
+  ASL_FontRequest       = 1;
+  ASL_ScreenModeRequest = 2;
+
+
+{****************************************************************************
+ *
+ * ASL File Requester data structures and constants
+ *
+ * This structure must only be allocated by asl.library amd is READ-ONLY!
+ * Control of the various fields is provided via tags when the requester
+ * is created with AllocAslRequest() and when it is displayed via
+ * AslRequest()
+ }
+
+type
+  PFileRequester = ^TFileRequester;
+  TFileRequester = record
+    rf_Reserved0   : array[0..3] of Byte;
+    rf_File        : STRPTR;        { Filename pointer             }
+    rf_Dir         : STRPTR;        { Directory name pointer       }
+    rf_Reserved1   : array[0..9] of Byte;
+    rf_LeftEdge    : SmallInt;
+    rf_TopEdge     : SmallInt;          { Preferred window pos }
+    rf_Width       : SmallInt;
+    rf_Height      : SmallInt;          { Preferred window size  }
+    rf_Reserved2   : array[0..1] of Byte;
+    rf_NumArgs     : LongInt;       { A-la WB Args, FOR multiselects }
+    rf_ArgList     : PWBArgList;
+    rf_UserData    : Pointer;       { Applihandle (you may write!!) }
+    rf_Reserved3   : array[0..7] of Byte;
+    rf_Pat         : STRPTR;        { Pattern match pointer }
+  END;                                { note - more reserved fields follow }
+
+
+{ File requester tag values, used by AllocAslRequest() and AslRequest() }
+
+const
+{ Window control }
+  ASLFR_Window         = ASL_TB+2 ;  { Parent window                    }
+  ASLFR_Screen         = ASL_TB+40;  { Screen to open on if no window   }
+  ASLFR_PubScreenName  = ASL_TB+41;  { Name of public screen            }
+  ASLFR_PrivateIDCMP   = ASL_TB+42;  { Allocate private IDCMP?          }
+  ASLFR_IntuiMsgFunc   = ASL_TB+70;  { function to handle IntuiMessages }
+  ASLFR_SleepWindow    = ASL_TB+43;  { Block input in ASLFR_Window?     }
+  ASLFR_UserData       = ASL_TB+52;  { What to put in fr_UserData       }
+  ASLFR_PopToFront     = ASL_TB+131; { Make the requester window visible }
+  ASLFR_Activate       = ASL_TB+132; { Activate the requester window when }
+
+{ Text display }
+  ASLFR_TextAttr       = ASL_TB+51;  { Text font to use for gadget text }
+  ASLFR_Locale         = ASL_TB+50;  { Locale ASL should use for text   }
+  ASLFR_TitleText      = ASL_TB+1 ;  { Title of requester               }
+  ASLFR_PositiveText   = ASL_TB+18;  { Positive gadget text             }
+  ASLFR_NegativeText   = ASL_TB+19;  { Negative gadget text             }
+
+{ Initial settings }
+  ASLFR_InitialLeftEdge= ASL_TB+3 ;  { Initial requester coordinates    }
+  ASLFR_InitialTopEdge = ASL_TB+4 ;
+  ASLFR_InitialWidth   = ASL_TB+5 ;  { Initial requester dimensions     }
+  ASLFR_InitialHeight  = ASL_TB+6 ;
+  ASLFR_InitialFile    = ASL_TB+8 ;  { Initial contents of File gadget  }
+  ASLFR_InitialDrawer  = ASL_TB+9 ;  { Initial contents of Drawer gadg. }
+  ASLFR_InitialPattern = ASL_TB+10;  { Initial contents of Pattern gadg.}
+  ASLFR_InitialShowVolumes = ASL_TB+130; { Initially, show the volume list (V44) }
+
+{ Options }
+  ASLFR_Flags1         = ASL_TB+20;  { Option flags                     }
+  ASLFR_Flags2         = ASL_TB+22;  { Additional option flags          }
+  ASLFR_DoSaveMode     = ASL_TB+44;  { Being used for saving?           }
+  ASLFR_DoMultiSelect  = ASL_TB+45;  { Do multi-select?                 }
+  ASLFR_DoPatterns     = ASL_TB+46;  { Display a Pattern gadget?        }
+
+{ Filtering }
+  ASLFR_DrawersOnly    = ASL_TB+47;  { Don't display files?             }
+  ASLFR_FilterFunc     = ASL_TB+49;  { function to filter files         }
+  ASLFR_RejectIcons    = ASL_TB+60;  { Display .info files?             }
+  ASLFR_RejectPattern  = ASL_TB+61;  { Don't display files matching pat }
+  ASLFR_AcceptPattern  = ASL_TB+62;  { Accept only files matching pat   }
+  ASLFR_FilterDrawers  = ASL_TB+63;  { Also filter drawers with patterns}
+  ASLFR_HookFunc       = ASL_TB+7 ;  { Combined callback function       }
+
+{ Sorting }
+  ASLFR_SetSortBy      = ASL_TB+124; { Sort criteria (name, date, size) }
+  ASLFR_GetSortBy      = ASL_TB+125;
+  ASLFR_SetSortDrawers = ASL_TB+126; { Placement of drawers in the list }
+  ASLFR_GetSortDrawers = ASL_TB+127;
+  ASLFR_SetSortOrder   = ASL_TB+128; { Order (ascending or descending)  }
+  ASLFR_GetSortOrder   = ASL_TB+129;
+
+
+{ Flag bits for the ASLFR_Flags1 tag }
+  FRB_FILTERFUNC     = 7;
+  FRB_INTUIFUNC      = 6;
+  FRB_DOSAVEMODE     = 5;
+  FRB_PRIVATEIDCMP   = 4;
+  FRB_DOMULTISELECT  = 3;
+  FRB_DOPATTERNS     = 0;
+
+  FRF_FILTERFUNC     = 128;
+  FRF_INTUIFUNC      = 64;
+  FRF_DOSAVEMODE     = 32;
+  FRF_PRIVATEIDCMP   = 16;
+  FRF_DOMULTISELECT  = 8;
+  FRF_DOPATTERNS     = 1;
+
+{ Flag bits for the ASLFR_Flags2 tag }
+  FRB_DRAWERSONLY    = 0;
+  FRB_FILTERDRAWERS  = 1;
+  FRB_REJECTICONS    = 2;
+
+  FRF_DRAWERSONLY    = 1;
+  FRF_FILTERDRAWERS  = 2;
+  FRF_REJECTICONS    = 4;
+
+{ Sort criteria for the ASLFR_SetSortBy/ASLFR_GetSortBy tags }
+  ASLFRSORTBY_Name   = 0;
+  ASLFRSORTBY_Date   = 1;
+  ASLFRSORTBY_Size   = 2;
+
+{ Drawer placement for the ASLFR_SetSortDrawers/ASLFR_GetSortDrawers tags }
+  ASLFRSORTDRAWERS_First  = 0;
+  ASLFRSORTDRAWERS_Mix    = 1;
+  ASLFRSORTDRAWERS_Last   = 2;
+
+{ Sort order for the ASLFR_SetSortOrder/ASLFR_GetSortOrder tags }
+  ASLFRSORTORDER_Ascend   = 0;
+  ASLFRSORTORDER_Descend  = 1;
+
+{****************************************************************************
+ *
+ * ASL Font Requester data structures and constants
+ *
+ * This structure must only be allocated by asl.library amd is READ-ONLY!
+ * Control of the various fields is provided via tags when the requester
+ * is created with AllocAslRequest() and when it is displayed via
+ * AslRequest()
+ }
+
+Type
+  PFontRequester = ^TFontRequester;
+  TFontRequester = record
+    fo_Reserved0        : array[0..7] of Byte;
+    fo_Attr             : TTextAttr;            { Returned TextAttr                }
+    fo_FrontPen         : Byte;                 { Returned front pen               }
+    fo_BackPen          : Byte;                 { Returned back pen                }
+    fo_DrawMode         : Byte;                 { Returned drawing mode            }
+    fo_Reserved1        : Byte;
+    fo_UserData         : Pointer;              { You can store your own data here }
+    fo_LeftEdge         : smallint;                 { Coordinates Of requester on Exit }
+    fo_TopEdge          : smallint;
+    fo_Width            : smallint;
+    fo_Height           : smallint;
+    fo_TAttr            : tTTextAttr;           { Returned TTextAttr               }
+  end;
+
+
+{ Font requester tag values, used by AllocAslRequest() AND AslRequest() }
+
+const
+{ Window control }
+  ASLFO_Window         = ASL_TB+2 ;  { Parent window                    }
+  ASLFO_Screen         = ASL_TB+40;  { Screen to open on if no window   }
+  ASLFO_PubScreenName  = ASL_TB+41;  { Name of public screen            }
+  ASLFO_PrivateIDCMP   = ASL_TB+42;  { Allocate private IDCMP?          }
+  ASLFO_IntuiMsgFunc   = ASL_TB+70;  { function to handle IntuiMessages }
+  ASLFO_SleepWindow    = ASL_TB+43;  { Block input in ASLFO_Window?     }
+  ASLFO_UserData       = ASL_TB+52;  { What to put in fo_UserData       }
+  ASLFO_PopToFront     = ASL_TB+131; { Make the requester window visible
+                                          * when it opens (V44)
+                                          }
+  ASLFO_Activate       = ASL_TB+132; { Activate the requester window when
+                                          * it opens (V45).
+                                          }
+{ Text display }
+  ASLFO_TextAttr       = ASL_TB+51;  { Text font to use for gadget text }
+  ASLFO_Locale         = ASL_TB+50;  { Locale ASL should use for text   }
+  ASLFO_TitleText      = ASL_TB+1 ;  { Title of requester               }
+  ASLFO_PositiveText   = ASL_TB+18;  { Positive gadget text             }
+  ASLFO_NegativeText   = ASL_TB+19;  { Negative gadget text             }
+
+{ Initial settings }
+  ASLFO_InitialLeftEdge= ASL_TB+3 ;  { Initial requester coordinates    }
+  ASLFO_InitialTopEdge = ASL_TB+4 ;
+  ASLFO_InitialWidth   = ASL_TB+5 ;  { Initial requester dimensions     }
+  ASLFO_InitialHeight  = ASL_TB+6 ;
+  ASLFO_InitialName    = ASL_TB+10;  { Initial contents of Name gadget  }
+  ASLFO_InitialSize    = ASL_TB+11;  { Initial contents of Size gadget  }
+  ASLFO_InitialStyle   = ASL_TB+12;  { Initial font style               }
+  ASLFO_InitialFlags   = ASL_TB+13;  { Initial font flags for TextAttr  }
+  ASLFO_InitialFrontPen= ASL_TB+14;  { Initial front pen                }
+  ASLFO_InitialBackPen = ASL_TB+15;  { Initial back pen                 }
+  ASLFO_InitialDrawMode= ASL_TB+59;  { Initial draw mode                }
+
+{ Options }
+  ASLFO_Flags          = ASL_TB+20;  { Option flags                     }
+  ASLFO_DoFrontPen     = ASL_TB+44;  { Display Front color selector?    }
+  ASLFO_DoBackPen      = ASL_TB+45;  { Display Back color selector?     }
+  ASLFO_DoStyle        = ASL_TB+46;  { Display Style checkboxes?        }
+  ASLFO_DoDrawMode     = ASL_TB+47;  { Display DrawMode cycle gadget?   }
+  ASLFO_SampleText     = ASL_TB+133; { Text to display in font sample area (V45) }
+
+{ Filtering }
+  ASLFO_FixedWidthOnly = ASL_TB+48;  { Only allow fixed-width fonts?    }
+  ASLFO_MinHeight      = ASL_TB+16;  { Minimum font height to display   }
+  ASLFO_MaxHeight      = ASL_TB+17;  { Maximum font height to display   }
+  ASLFO_FilterFunc     = ASL_TB+49;  { function to filter fonts         }
+  ASLFO_HookFunc       = ASL_TB+7 ;  { Combined callback function       }
+  ASLFO_MaxFrontPen    = ASL_TB+66;  { Max # of colors in front palette }
+  ASLFO_MaxBackPen     = ASL_TB+67;  { Max # of colors in back palette  }
+
+{ Custom additions }
+  ASLFO_ModeList       = ASL_TB+21;  { Substitute list for drawmodes    }
+  ASLFO_FrontPens      = ASL_TB+64;  { Color table for front pen palette}
+  ASLFO_BackPens       = ASL_TB+65;  { Color table for back pen palette }
+
+{ Flag bits for ASLFO_Flags tag }
+  FOB_DOFRONTPEN    =  0;
+  FOB_DOBACKPEN     =  1;
+  FOB_DOSTYLE       =  2;
+  FOB_DODRAWMODE    =  3;
+  FOB_FIXEDWIDTHONLY=  4;
+  FOB_PRIVATEIDCMP  =  5;
+  FOB_INTUIFUNC     =  6;
+  FOB_FILTERFUNC    =  7;
+
+  FOF_DOFRONTPEN     = 1;
+  FOF_DOBACKPEN      = 2;
+  FOF_DOSTYLE        = 4;
+  FOF_DODRAWMODE     = 8;
+  FOF_FIXEDWIDTHONLY = 16;
+  FOF_PRIVATEIDCMP   = 32;
+  FOF_INTUIFUNC      = 64;
+  FOF_FILTERFUNC     = 128;
+
+{****************************************************************************
+ *
+ * ASL Screen Mode Requester data structures and constants
+ *
+ * This structure must only be allocated by asl.library and is READ-ONLY!
+ * Control of the various fields is provided via tags when the requester
+ * is created with AllocAslRequest() and when it is displayed via
+ * AslRequest()
+ }
+
+type
+  PScreenModeRequester = ^TScreenModeRequester;
+  TScreenModeRequester = record
+    sm_DisplayID        : LongWord;    { Display mode ID                  }
+    sm_DisplayWidth     : LongWord;    { Width Of display IN pixels       }
+    sm_DisplayHeight    : LongWord;    { Height Of display IN pixels      }
+    sm_DisplayDepth     : Word;     { Number OF bit-planes OF display  }
+    sm_OverscanType     : Word;     { TYPE OF overscan OF display      }
+    sm_AutoScroll       : Boolean;  { Display should auto-scroll?      }
+
+    sm_BitMapWidth      : LongWord;    { Used TO create your own BitMap   }
+    sm_BitMapHeight     : LongWord;
+
+    sm_LeftEdge         : smallint;     { Coordinates OF requester on Exit }
+    sm_TopEdge          : smallint;
+    sm_Width            : smallint;
+    sm_Height           : smallint;
+
+    sm_InfoOpened       : Boolean;  { Info window opened on exit?      }
+    sm_InfoLeftEdge     : smallint;     { Last coordinates OF Info window  }
+    sm_InfoTopEdge      : smallint;
+    sm_InfoWidth        : smallint;
+    sm_InfoHeight       : smallint;
+
+    sm_UserData         : Pointer;     { You can store your own data here }
+  end;
+
+
+{ An Exec list of custom modes can be added to the list of available modes.
+ * The DimensionInfo structure must be completely initialized, including the
+ * Header. See <graphics/displayinfo.h>. Custom mode ID's must be in the range
+ * $FFFF0000..$FFFFFFFF. Regular properties which apply to your custom modes
+ * can be added in the dn_PropertyFlags field. Custom properties are not
+ * allowed.
+ }
+  PDisplayMode = ^TDisplayMode;
+  TDisplayMode = record
+    dm_Node          : TNode;            { see ln_Name           }
+    dm_DimensionInfo : tDimensionInfo;   { mode description      }
+    dm_PropertyFlags : LongWord;         { applicable properties }
+  end;
+
+
+{ ScreenMode requester tag values, used by AllocAslRequest() and AslRequest() }
+const
+{ Window control }
+  ASLSM_Window        =  ASL_TB+2 ;  { Parent window                    }
+  ASLSM_Screen        =  ASL_TB+40;  { Screen to open on if no window   }
+  ASLSM_PubScreenName =  ASL_TB+41;  { Name of public screen            }
+  ASLSM_PrivateIDCMP  =  ASL_TB+42;  { Allocate private IDCMP?          }
+  ASLSM_IntuiMsgFunc  =  ASL_TB+70;  { function to handle IntuiMessages }
+  ASLSM_SleepWindow   =  ASL_TB+43;  { Block input in ASLSM_Window?     }
+  ASLSM_UserData      =  ASL_TB+52;  { What to put in sm_UserData       }
+  ASLSM_PopToFront    =  ASL_TB+131; { Make the requester window visible
+                                          * when it opens (V44)
+                                          }
+  ASLSM_Activate      =  ASL_TB+132; { Activate the requester window when
+                                          * it opens (V45).
+                                          }
+
+{ Text display }
+  ASLSM_TextAttr      =  ASL_TB+51;  { Text font to use for gadget text }
+  ASLSM_Locale        =  ASL_TB+50;  { Locale ASL should use for text   }
+  ASLSM_TitleText     =  ASL_TB+1 ;  { Title of requester               }
+  ASLSM_PositiveText  =  ASL_TB+18;  { Positive gadget text             }
+  ASLSM_NegativeText  =  ASL_TB+19;  { Negative gadget text             }
+
+{ Initial settings }
+  ASLSM_InitialLeftEdge      = ASL_TB+3  ; { Initial requester coordinates    }
+  ASLSM_InitialTopEdge       = ASL_TB+4  ;
+  ASLSM_InitialWidth         = ASL_TB+5  ; { Initial requester dimensions     }
+  ASLSM_InitialHeight        = ASL_TB+6  ;
+  ASLSM_InitialDisplayID     = ASL_TB+100; { Initial display mode id     }
+  ASLSM_InitialDisplayWidth  = ASL_TB+101; { Initial display width       }
+  ASLSM_InitialDisplayHeight = ASL_TB+102; { Initial display height      }
+  ASLSM_InitialDisplayDepth  = ASL_TB+103; { Initial display depth       }
+  ASLSM_InitialOverscanType  = ASL_TB+104; { Initial type of overscan    }
+  ASLSM_InitialAutoScroll    = ASL_TB+105; { Initial autoscroll setting  }
+  ASLSM_InitialInfoOpened    = ASL_TB+106; { Info wndw initially opened? }
+  ASLSM_InitialInfoLeftEdge  = ASL_TB+107; { Initial Info window coords. }
+  ASLSM_InitialInfoTopEdge   = ASL_TB+108;
+
+{ Options }
+  ASLSM_DoWidth         = ASL_TB+109;  { Display Width gadget?           }
+  ASLSM_DoHeight        = ASL_TB+110;  { Display Height gadget?          }
+  ASLSM_DoDepth         = ASL_TB+111;  { Display Depth gadget?           }
+  ASLSM_DoOverscanType  = ASL_TB+112;  { Display Overscan Type gadget?   }
+  ASLSM_DoAutoScroll    = ASL_TB+113;  { Display AutoScroll gadget?      }
+
+{ Filtering }
+  ASLSM_PropertyFlags   = ASL_TB+114;  { Must have these Property flags  }
+  ASLSM_PropertyMask    = ASL_TB+115;  { Only these should be looked at  }
+  ASLSM_MinWidth        = ASL_TB+116;  { Minimum display width to allow  }
+  ASLSM_MaxWidth        = ASL_TB+117;  { Maximum display width to allow  }
+  ASLSM_MinHeight       = ASL_TB+118;  { Minimum display height to allow }
+  ASLSM_MaxHeight       = ASL_TB+119;  { Maximum display height to allow }
+  ASLSM_MinDepth        = ASL_TB+120;  { Minimum display depth           }
+  ASLSM_MaxDepth        = ASL_TB+121;  { Maximum display depth           }
+  ASLSM_FilterFunc      = ASL_TB+122;  { function to filter mode id's    }
+
+{ Custom additions }
+  ASLSM_CustomSMList    = ASL_TB+123;  { Exec list of struct DisplayMode }
+
+{***************************************************************************}
+
+  ASL_LAST_TAG  = ASL_TB+133;
+
+{***************************************************************************}
+
+{ This defines the rendezvous data for setting and querying asl.library's
+ * defaults for the window size and the file requester sort order. The name
+ * of the semaphore is given below; it exists only with asl.library V45 and
+ * IPrefs V45 and beyond.
+ }
+  ASL_SEMAPHORE_NAME  : Pchar = 'asl.library';
+
+type
+  PAslSemaphore = ^TAslSemaphore;
+  TAslSemaphore = record
+    as_Semaphore : TSignalSemaphore;
+    as_Version : Word;         { Must be >= 45 }
+    as_Size : LongWord;        { Size of this data structure. }
+    as_SortBy : Byte;          { File requester defaults; name, date or size }
+    as_SortDrawers : Byte;     { File requester defaults; first, mix or last }
+    as_SortOrder : Byte;       { File requester defaults; ascending or descending }
+    as_SizePosition : Byte;    { See below }
+    as_RelativeLeft : Smallint;{ Window position offset }
+    as_RelativeTop : Smallint;
+    as_RelativeWidth : Byte;   { Window size factor; this is
+                                * a percentage of the parent
+                                * window/screen width.
+                                }
+    as_RelativeHeight : Byte;
+   end;
+
+const
+{ Default position of the ASL window. }
+  ASLPOS_DefaultPosition  = 0;  { Position is calculated according to the builtin rules. }
+  ASLPOS_CenterWindow     = 1;  { Centred within the bounds of the parent window. }
+  ASLPOS_CenterScreen     = 2;  { Centred within the bounds of the parent screen. }
+  ASLPOS_WindowPosition   = 3;  { Relative to the top left corner of the parent window,
+                                         * using the offset values provided in the
+                                         * as_RelativeLeft/as_RelativeTop members.
+                                         }
+  ASLPOS_ScreenPosition   = 4;  { Relative to the top left corner of the parent screen,
+                                         * using the offset values provided in the
+                                         * as_RelativeLeft/as_RelativeTop members.
+                                         }
+  ASLPOS_CenterMouse      = 5;  { Directly below the mouse pointer. }
+  ASLPOS_MASK             = $0F;
+
+{ Default size of the ASL window. }
+  ASLSIZE_DefaultSize   = (0 shl 4);    { Size is calculated according to the builtin rules. }
+  ASLSIZE_RelativeSize  = (1 shl 4);    { Size is relative to the size of the parent
+                                         * window or screen, using the values provided in
+                                         * the as_RelativeWidth/as_RelativeHeight members.
+                                         * The as_RelativeWidth/as_RelativeHeight values are
+                                         * taken as percentage, i.e. a value of "50" stands for
+                                         * 50% of the width/height of the parent window/screen.
+                                         }
+  ASLSIZE_MASK          = $30;
+
+{ Other options. }
+  ASLOPTION_ASLOverrides   = (1 shl 6); { ASL determines placement and size of requester
+                                         * windows; application's choice is ignored.
+                                         }
+
+
+{****************************************************************************
+ *
+ * Obsolete ASL definitions, here for source code compatibility only.
+ * Please do NOT use in new code.
+ *
+ *   define ASL_V38_NAMES_ONLY to remove these older names
+ }
+{$define ASL_V38_NAMES_ONLY}
+{$ifndef ASL_V38_NAMES_ONLY}
+Const
+  ASL_Dummy       = (TAG_USER + $80000);
+  ASL_Hail        = ASL_Dummy+1 ;
+  ASL_Window      = ASL_Dummy+2 ;
+  ASL_LeftEdge    = ASL_Dummy+3 ;
+  ASL_TopEdge     = ASL_Dummy+4 ;
+  ASL_Width       = ASL_Dummy+5 ;
+  ASL_Height      = ASL_Dummy+6 ;
+  ASL_HookFunc    = ASL_Dummy+7 ;
+  ASL_File        = ASL_Dummy+8 ;
+  ASL_Dir         = ASL_Dummy+9 ;
+  ASL_FontName    = ASL_Dummy+10;
+  ASL_FontHeight  = ASL_Dummy+11;
+  ASL_FontStyles  = ASL_Dummy+12;
+  ASL_FontFlags   = ASL_Dummy+13;
+  ASL_FrontPen    = ASL_Dummy+14;
+  ASL_BackPen     = ASL_Dummy+15;
+  ASL_MinHeight   = ASL_Dummy+16;
+  ASL_MaxHeight   = ASL_Dummy+17;
+  ASL_OKText      = ASL_Dummy+18;
+  ASL_CancelText  = ASL_Dummy+19;
+  ASL_FuncFlags   = ASL_Dummy+20;
+  ASL_ModeList    = ASL_Dummy+21;
+  ASL_ExtFlags1   = ASL_Dummy+22;
+  ASL_Pattern     = ASL_FontName;
+{ remember what I said up there? Do not use these anymore! }
+  FILB_DOWILDFUNC  = 7;
+  FILB_DOMSGFUNC   = 6;
+  FILB_SAVE        = 5;
+  FILB_NEWIDCMP    = 4;
+  FILB_MULTISELECT = 3;
+  FILB_PATGAD      = 0;
+  FILF_DOWILDFUNC  = 128;
+  FILF_DOMSGFUNC   = 64;
+  FILF_SAVE        = 32;
+  FILF_NEWIDCMP    = 16;
+  FILF_MULTISELECT = 8;
+  FILF_PATGAD      = 1;
+  FIL1B_NOFILES    = 0;
+  FIL1B_MATCHDIRS  = 1;
+  FIL1F_NOFILES    = 1;
+  FIL1F_MATCHDIRS  = 2;
+  FONB_FRONTCOLOR  = 0;
+  FONB_BACKCOLOR   = 1;
+  FONB_STYLES      = 2;
+  FONB_DRAWMODE    = 3;
+  FONB_FIXEDWIDTH  = 4;
+  FONB_NEWIDCMP    = 5;
+  FONB_DOMSGFUNC   = 6;
+  FONB_DOWILDFUNC  = 7;
+  FONF_FRONTCOLOR  = 1;
+  FONF_BACKCOLOR   = 2;
+  FONF_STYLES      = 4;
+  FONF_DRAWMODE    = 8;
+  FONF_FIXEDWIDTH  = 16;
+  FONF_NEWIDCMP    = 32;
+  FONF_DOMSGFUNC   = 64;
+  FONF_DOWILDFUNC  = 128;
+{$endif ASL_V38_NAMES_ONLY}
+
+var
+  AslBase: PLibrary;
+
+
+function AllocAslRequestA(ReqType: LongWord; TagList: PTagItem): Pointer; syscall AslBase 8;
+function AllocFileRequest: PFileRequester; syscall AslBase 5;
+function AslRequestA(Requester: Pointer; TagList: PTagItem): LongBool; syscall AslBase 10;
+procedure FreeAslRequest(Requester: Pointer); syscall AslBase 9;
+procedure FreeFileRequest(FileReq: PFileRequester); syscall AslBase 6;
+function RequestFile(FileReq: PFileRequester): LongBool; syscall AslBase 7;
+
+procedure AbortAslRequest(Requester: Pointer); syscall AslBase 13;
+procedure ActivateAslRequest(Requester: Pointer); syscall AslBase 14;
+
+
+function AllocAslRequest(ReqType: LongWord; const Tags: array of const): Pointer;
+function AslRequest(Requester: Pointer; const Tags: array of const): LongBool;
+
+
+implementation
+
+
+function AllocAslRequest(ReqType: LongWord; const Tags: array of const): Pointer;
+begin
+  AllocAslRequest := AllocAslRequestA(reqType , readintags(tags));
+end;
+
+function AslRequest(Requester: Pointer; const Tags: array of const): LongBool;
+begin
+  AslRequest := AslRequestA(Requester , readintags(tags));
+end;
+
+initialization
+  AslBase := OpenLibrary(ASLNAME, 36);
+finalization
+  CloseLibrary(AslBase);
+
+end.
+
+

+ 482 - 0
packages/arosunits/src/gadtools.pas

@@ -0,0 +1,482 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2014 by Free Pascal development team
+
+    gadtools.library functions
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+
+unit gadtools;
+
+interface
+
+uses
+  exec, intuition, agraphics, utility;
+
+{------------------------------------------------------------------------}
+
+{  The kinds (almost classes) of gadgets in the toolkit.  Use these
+    identifiers when calling CreateGadgetA() }
+
+CONST
+ GENERIC_KIND  =  0;
+ BUTTON_KIND   =  1;
+ CHECKBOX_KIND =  2;
+ INTEGER_KIND  =  3;
+ LISTVIEW_KIND =  4;
+ MX_KIND       =  5;
+ NUMBER_KIND   =  6;
+ CYCLE_KIND    =  7;
+ PALETTE_KIND  =  8;
+ SCROLLER_KIND =  9;
+{ Kind number 10 is reserved }
+ SLIDER_KIND   =  11;
+ STRING_KIND   =  12;
+ TEXT_KIND     =  13;
+
+ NUM_KINDS     =  14;
+
+ GADTOOLSNAME   : PChar = 'gadtools.library';
+
+
+{------------------------------------------------------------------------}
+
+{  'Or' the appropriate set together for your Window IDCMPFlags: }
+
+ ARROWIDCMP    =  (IDCMP_GADGETUP + IDCMP_GADGETDOWN +
+                   IDCMP_INTUITICKS + IDCMP_MOUSEBUTTONS);
+
+ BUTTONIDCMP   =  (IDCMP_GADGETUP);
+ CHECKBOXIDCMP =  (IDCMP_GADGETUP);
+ INTEGERIDCMP  =  (IDCMP_GADGETUP);
+ LISTVIEWIDCMP =  (IDCMP_GADGETUP + IDCMP_GADGETDOWN +
+                   IDCMP_MOUSEMOVE + ARROWIDCMP);
+
+ MXIDCMP       =  (IDCMP_GADGETDOWN);
+ NUMBERIDCMP   =  0;
+ CYCLEIDCMP    =  (IDCMP_GADGETUP);
+ PALETTEIDCMP  =  (IDCMP_GADGETUP);
+
+{  Use ARROWIDCMP+SCROLLERIDCMP if your scrollers have arrows: }
+ SCROLLERIDCMP =  (IDCMP_GADGETUP + IDCMP_GADGETDOWN + IDCMP_MOUSEMOVE);
+ SLIDERIDCMP   =  (IDCMP_GADGETUP + IDCMP_GADGETDOWN + IDCMP_MOUSEMOVE);
+ STRINGIDCMP   =  (IDCMP_GADGETUP);
+
+ TEXTIDCMP     =  0;
+
+
+{------------------------------------------------------------------------}
+
+{  Generic NewGadget used by several of the gadget classes: }
+
+Type
+   PNewGadget = ^tNewGadget;
+   tNewGadget = record
+    ng_LeftEdge, ng_TopEdge : SmallInt;     {  gadget position }
+    ng_Width, ng_Height     : SmallInt;     {  gadget size }
+    ng_GadgetText           : STRPTR;      {  gadget label }
+    ng_TextAttr             : PTextAttr;   {  desired font for gadget label }
+    ng_GadgetID             : Word;        {  gadget ID }
+    ng_Flags                : LongWord;       {  see below }
+    ng_VisualInfo           : Pointer;     {  Set to retval of GetVisualInfo() }
+    ng_UserData             : Pointer;     {  gadget UserData }
+   END;
+
+
+{  ng_Flags control certain aspects of the gadget.  The first five control
+    the placement of the descriptive text.  All larger groups supply a
+    default: }
+
+CONST
+ PLACETEXT_LEFT  = $0001;  { Right-align text on left side }
+ PLACETEXT_RIGHT = $0002;  { Left-align text on right side }
+ PLACETEXT_ABOVE = $0004;  { Center text above }
+ PLACETEXT_BELOW = $0008;  { Center text below }
+ PLACETEXT_IN    = $0010;  { Center text on }
+
+ NG_HIGHLABEL    = $0020;  { Highlight the label }
+
+{------------------------------------------------------------------------}
+
+{ Fill out an array of these and pass that to CreateMenus(): }
+
+Type
+   pNewMenu = ^tNewMenu;
+   tNewMenu = record
+    nm_Type           : Byte;              {  See below }
+    nm_Label          : STRPTR;            {  Menu's label }
+    nm_CommKey        : STRPTR;            {  MenuItem Command Key Equiv }
+    nm_Flags          : Word;              {  Menu OR MenuItem flags (see note) }
+    nm_MutualExclude  : Longint;           {  MenuItem MutualExclude word }
+    nm_UserData       : Pointer;           {  For your own use, see note }
+   END;
+
+const
+{ Needed only by inside IM_ definitions below }
+ MENU_IMAGE     = 128;
+
+{ nm_Type determines what each NewMenu structure corresponds to.
+ * for the NM_TITLE, NM_ITEM, and NM_SUB values, nm_Label should
+ * be a text string to use for that menu title, item, or sub-item.
+ * For IM_ITEM or IM_SUB, set nm_Label to point at the Image structure
+ * you wish to use for this item or sub-item.
+ * NOTE: At present, you may only use conventional images.
+ * Custom images created from Intuition image-classes do not work.
+ }
+ NM_TITLE      =  1;       { Menu header }
+ NM_ITEM       =  2;       { Textual menu item }
+ NM_SUB        =  3;       { Textual menu sub-item }
+
+ IM_ITEM       =  (NM_ITEM OR MENU_IMAGE);    { Graphical menu item }
+ IM_SUB        =  (NM_SUB OR MENU_IMAGE);     { Graphical menu sub-item }
+
+{ The NewMenu array should be terminated with a NewMenu whose
+ * nm_Type equals NM_END.
+ }
+ NM_END        =  0;       { End of NewMenu array }
+
+{ Starting with V39, GadTools will skip any NewMenu entries whose
+ * nm_Type field has the NM_IGNORE bit set.
+ }
+ NM_IGNORE     =  64;
+
+
+{ nm_Label should be a text string for textual items, a pointer
+ * to an Image structure for graphical menu items, or the special
+ * constant NM_BARLABEL, to get a separator bar.
+ }
+ NM_BARLABEL   = -1;
+
+{ The nm_Flags field is used to fill out either the Menu->Flags or
+ * MenuItem->Flags field.  Note that the sense of the MENUENABLED or
+ * ITEMENABLED bit is inverted between this use and Intuition's use,
+ * in other words, NewMenus are enabled by default.  The following
+ * labels are provided to disable them:
+ }
+ NM_MENUDISABLED = MENUENABLED;
+ NM_ITEMDISABLED = ITEMENABLED;
+
+{ New for V39:  NM_COMMANDSTRING.  For a textual MenuItem or SubItem,
+ * point nm_CommKey at an arbitrary string, and set the NM_COMMANDSTRING
+ * flag.
+ }
+ NM_COMMANDSTRING = COMMSEQ;
+
+{ The following are pre-cleared (COMMSEQ, ITEMTEXT, and HIGHxxx are set
+ * later as appropriate):
+ * Under V39, the COMMSEQ flag bit is not cleared, since it now has
+ * meaning.
+ }
+ NM_FLAGMASK    = not (COMMSEQ or ITEMTEXT or HIGHFLAGS);
+ NM_FLAGMASK_V39 = not (ITEMTEXT or HIGHFLAGS);
+
+{ You may choose among CHECKIT, MENUTOGGLE, and CHECKED.
+ * Toggle-select menuitems are of type CHECKIT|MENUTOGGLE, along
+ * with CHECKED if currently selected.  Mutually exclusive ones
+ * are of type CHECKIT, and possibly CHECKED too.  The nm_MutualExclude
+ * is a bit-wise representation of the items excluded by this one,
+ * so in the simplest case (choose 1 among n), these flags would be
+ * ~1, ~2, ~4, ~8, ~16, etc.  See the Intuition Menus chapter.
+ }
+
+{ A UserData pointer can be associated with each Menu and MenuItem structure.
+ * The CreateMenus() call allocates space for a UserData after each
+ * Menu or MenuItem (header, item or sub-item).  You should use the
+ * GTMENU_USERDATA() or GTMENUITEM_USERDATA() macro to extract it.
+ }
+
+const
+{ These return codes can be obtained through the GTMN_SecondaryError tag }
+ GTMENU_TRIMMED = $00000001;      { Too many menus, items, or subitems,
+                                         * menu has been trimmed down
+                                         }
+ GTMENU_INVALID = $00000002;      { Invalid NewMenu array }
+ GTMENU_NOMEM   = $00000003;      { Out of memory }
+
+{------------------------------------------------------------------------}
+
+{ Starting with V39, checkboxes and mx gadgets can be scaled to your
+ * specified gadget width/height.  Use the new GTCB_Scaled or GTMX_Scaled
+ * tags, respectively.  Under V37, and by default in V39, the imagery
+ * is of the following fixed size:
+ }
+
+{ MX gadget default dimensions: }
+ MX_WIDTH      =  17;
+ MX_HEIGHT     =  9;
+
+{ Checkbox default dimensions: }
+ CHECKBOX_WIDTH  = 26;
+ CHECKBOX_HEIGHT = 11;
+
+{------------------------------------------------------------------------}
+
+
+{------------------------------------------------------------------------}
+
+{  Tags for GadTools functions: }
+CONST
+ GT_TagBase        =   TAG_USER + $80000;
+
+ GTVI_NewWindow    =   GT_TagBase+1;  { Unused }
+ GTVI_NWTags       =   GT_TagBase+2;  { Unused }
+
+ GT_Private0       =   GT_TagBase+3;  { (private) }
+
+ GTCB_Checked      =   GT_TagBase+4;  { State of checkbox }
+
+ GTLV_Top          =   GT_TagBase+5;  { Top visible one in listview }
+ GTLV_Labels       =   GT_TagBase+6;  { List to display in listview }
+ GTLV_ReadOnly     =   GT_TagBase+7;  { TRUE IF listview is to be
+                                              read-only }
+ GTLV_ScrollWidth  =   GT_TagBase+8;  { Width of scrollbar }
+
+ GTMX_Labels       =   GT_TagBase+9;  { NULL-terminated array of labels }
+ GTMX_Active       =   GT_TagBase+10; { Active one in mx gadget }
+
+ GTTX_Text         =   GT_TagBase+11; { Text to display }
+ GTTX_CopyText     =   GT_TagBase+12; { Copy text label instead of
+                                              referencing it }
+
+ GTNM_Number       =   GT_TagBase+13; { Number to display }
+
+ GTCY_Labels       =   GT_TagBase+14; { NULL-terminated array of labels }
+ GTCY_Active       =   GT_TagBase+15; { The active one in the cycle gad }
+
+ GTPA_Depth        =   GT_TagBase+16; { Number of bitplanes in palette }
+ GTPA_Color        =   GT_TagBase+17; { Palette color }
+ GTPA_ColorOffset  =   GT_TagBase+18; { First color to use in palette }
+ GTPA_IndicatorWidth = GT_TagBase+19; { Width of current-color indicator }
+ GTPA_IndicatorHeight = GT_TagBase+20; { Height of current-color indicator }
+
+ GTSC_Top          =   GT_TagBase+21; { Top visible in scroller }
+ GTSC_Total        =   GT_TagBase+22; { Total in scroller area }
+ GTSC_Visible      =   GT_TagBase+23; { Number visible in scroller }
+ GTSC_Overlap      =   GT_TagBase+24; { Unused }
+
+{  GT_TagBase+25 through GT_TagBase+37 are reserved }
+
+ GTSL_Min          =   GT_TagBase+38; { Slider min value }
+ GTSL_Max          =   GT_TagBase+39; { Slider max value }
+ GTSL_Level        =   GT_TagBase+40; { Slider level }
+ GTSL_MaxLevelLen  =   GT_TagBase+41; { Max length of printed level }
+ GTSL_LevelFormat  =   GT_TagBase+42; { Format string for level }
+ GTSL_LevelPlace   =   GT_TagBase+43; { Where level should be placed }
+ GTSL_DispFunc     =   GT_TagBase+44; { Callback for number calculation
+                                              before display }
+
+ GTST_String       =   GT_TagBase+45; { String gadget's displayed string }
+ GTST_MaxChars     =   GT_TagBase+46; { Max length of string }
+
+ GTIN_Number       =   GT_TagBase+47; { Number in integer gadget }
+ GTIN_MaxChars     =   GT_TagBase+48; { Max number of digits }
+
+ GTMN_TextAttr     =   GT_TagBase+49; { MenuItem font TextAttr }
+ GTMN_FrontPen     =   GT_TagBase+50; { MenuItem text pen color }
+
+ GTBB_Recessed     =   GT_TagBase+51; { Make BevelBox recessed }
+
+ GT_VisualInfo     =   GT_TagBase+52; { result of VisualInfo call }
+
+ GTLV_ShowSelected =   GT_TagBase+53; { show selected entry beneath
+                listview, set tag data = NULL for display-only, or pointer
+                to a string gadget you've created }
+ GTLV_Selected     =   GT_TagBase+54; { Set ordinal number of selected
+                                              entry in the list }
+ GT_Reserved0      =   GT_TagBase+55; { Reserved }
+ GT_Reserved1      =   GT_TagBase+56; { Reserved for future use }
+
+ GTTX_Border       =   GT_TagBase+57; { Put a border around
+                                              Text-display gadgets }
+ GTNM_Border       =   GT_TagBase+58; { Put a border around
+                                              Number-display gadgets }
+
+ GTSC_Arrows       =   GT_TagBase+59; { Specify size of arrows for
+                                              scroller }
+
+ GTMN_Menu         =   GT_TagBase+60; { Pointer to Menu for use by
+                                              LayoutMenuItems() }
+ GTMX_Spacing      =   GT_TagBase+61; { Added to font height to
+                figure spacing between mx choices.  Use this instead
+                of LAYOUTA_SPACING for mx gadgets. }
+
+{ New to V37 GadTools.  Ignored by GadTools V36 }
+ GTMN_FullMenu     =   GT_TagBase+62; { Asks CreateMenus() to
+                validate that this is a complete menu structure }
+ GTMN_SecondaryError =  GT_TagBase+63; { ti_Data is a pointer
+                to a LongWord to receive error reports from CreateMenus() }
+ GT_Underscore     =   GT_TagBase+64; { ti_Data points to the symbol
+                that preceeds the character you'd like to underline in a
+                gadget label }
+
+{ New to V39 GadTools.  Ignored by GadTools V36 and V37 }
+ GTMN_Checkmark     =  GT_TagBase+65; { ti_Data is checkmark img to use }
+ GTMN_AmigaKey      =  GT_TagBase+66; { ti_Data is Amiga-key img to use }
+ GTMN_NewLookMenus  =  GT_TagBase+67; { ti_Data is boolean }
+
+{ New to V39 GadTools.  Ignored by GadTools V36 and V37.
+ * Set to TRUE if you want the checkbox or mx image scaled to
+ * the gadget width/height you specify.  Defaults to FALSE,
+ * for compatibility.
+ }
+ GTCB_Scaled         = GT_TagBase+68; { ti_Data is boolean }
+ GTMX_Scaled         = GT_TagBase+69; { ti_Data is boolean }
+
+ GTPA_NumColors      = GT_TagBase+70; { Number of colors in palette }
+
+ GTMX_TitlePlace     = GT_TagBase+71; { Where to put the title }
+
+ GTTX_FrontPen       = GT_TagBase+72; { Text color in TEXT_KIND gad }
+ GTTX_BackPen        = GT_TagBase+73; { Bgrnd color in TEXT_KIND gad }
+ GTTX_Justification  = GT_TagBase+74; { See GTJ_#? constants }
+
+ GTNM_FrontPen       = GT_TagBase+72; { Text color in NUMBER_KIND gad }
+ GTNM_BackPen        = GT_TagBase+73; { Bgrnd color in NUMBER_KIND gad }
+ GTNM_Justification  = GT_TagBase+74; { See GTJ_#? constants }
+ GTNM_Format         = GT_TagBase+75; { Formatting string for number }
+ GTNM_MaxNumberLen   = GT_TagBase+76; { Maximum length of number }
+
+ GTBB_FrameType      = GT_TagBase+77; { defines what kind of boxes
+                                            * DrawBevelBox() renders. See
+                                            * the BBFT_#? constants for
+                                            * possible values
+                                            }
+
+ GTLV_MakeVisible    = GT_TagBase+78; { Make this item visible }
+ GTLV_ItemHeight     = GT_TagBase+79; { Height of an individual item }
+
+ GTSL_MaxPixelLen    = GT_TagBase+80; { Max pixel size of level display }
+ GTSL_Justification  = GT_TagBase+81; { how should the level be displayed }
+
+ GTPA_ColorTable     = GT_TagBase+82; { colors to use in palette }
+
+ GTLV_CallBack       = GT_TagBase+83; { general-purpose listview call back }
+ GTLV_MaxPen         = GT_TagBase+84; { maximum pen number used by call back }
+
+ GTTX_Clipped        = GT_TagBase+85; { make a TEXT_KIND clip text }
+ GTNM_Clipped        = GT_TagBase+85; { make a NUMBER_KIND clip text }
+
+
+{------------------------------------------------------------------------}
+
+{ Justification types for GTTX_Justification and GTNM_Justification tags }
+ GTJ_LEFT   = 0;
+ GTJ_RIGHT  = 1;
+ GTJ_CENTER = 2;
+
+{------------------------------------------------------------------------}
+
+{ Bevel box frame types for GTBB_FrameType tag }
+ BBFT_BUTTON      = 1;  { Standard button gadget box }
+ BBFT_RIDGE       = 2;  { Standard string gadget box }
+ BBFT_ICONDROPBOX = 3;  { Standard icon drop box     }
+
+{------------------------------------------------------------------------}
+
+{ Typical suggested spacing between "elements": }
+ INTERWIDTH    =  8;
+ INTERHEIGHT   =  4;
+
+{------------------------------------------------------------------------}
+
+
+{  "NWay" is an old synonym for cycle gadgets }
+ NWAY_KIND    =   CYCLE_KIND;
+ NWAYIDCMP    =   CYCLEIDCMP;
+ GTNW_Labels  =   GTCY_Labels;
+ GTNW_Active  =   GTCY_Active;
+
+{------------------------------------------------------------------------}
+
+{ These two definitions are obsolete, but are here for backwards
+ * compatibility.  You never need to worry about these:
+ }
+ GADTOOLBIT    =  ($8000);
+{ Use this mask to isolate the user part: }
+ GADTOOLMASK   =  not (GADTOOLBIT);
+
+{------------------------------------------------------------------------}
+
+{ These definitions are for the GTLV_CallBack tag }
+
+{ The different types of messages that a listview callback hook can see }
+ LV_DRAW     =  $202;    { draw yourself, with state }
+
+{ Possible return values from a callback hook }
+ LVCB_OK      = 0;         { callback understands this message type    }
+ LVCB_UNKNOWN = 1;         { callback does not understand this message }
+
+{ states for LVDrawMsg.lvdm_State }
+ LVR_NORMAL           = 0; { the usual                 }
+ LVR_SELECTED         = 1; { for selected gadgets      }
+ LVR_NORMALDISABLED   = 2;         { for disabled gadgets      }
+ LVR_SELECTEDDISABLED = 8;         { disabled and selected     }
+
+Type
+{ structure of LV_DRAW messages, object is a (struct Node *) }
+ pLVDrawMsg = ^tLVDrawMsg;
+ tLVDrawMsg = record
+    lvdm_MethodID       : LongWord;       { LV_DRAW                   }
+    lvdm_RastPort       : PRastPort;   { where to render to        }
+    lvdm_DrawInfo       : PDrawInfo;   { useful to have around     }
+    lvdm_Bounds         : TRectangle;  { limits of where to render }
+    lvdm_State          : LongWord;     { how to render     }
+ end;
+
+
+var
+  GadToolsBase: PLibrary;
+
+function CreateContext(GListPtr: PGadget): PGadget; syscall GadToolsBase 19;
+function CreateGadgetA(Kind: LongWord; Gad: PGadget; const ng: PNewGadget; const TagList: PTagItem): PGadget; syscall GadToolsBase 5;
+function CreateMenusA(const NewMenu: PNewMenu; const TagList: PTagItem): PMenu; syscall GadToolsBase 8;
+procedure DrawBevelBoxA(RPort: PRastPort; Left: LongInt; Top: LongInt; Width: LongInt; Height: LongInt; const TagList: PTagItem); syscall GadToolsBase 20;
+procedure FreeGadgets(Gad: PGadget); syscall GadToolsBase 6;
+procedure FreeMenus(Menu: PMenu); syscall GadToolsBase 9;
+procedure FreeVisualInfo(vi: Pointer); syscall GadToolsBase 22;
+function GetVisualInfoA(Screen: PScreen; const TagList: PTagItem): Pointer; syscall GadToolsBase 21;
+procedure GT_BeginRefresh(Win: PWindow); syscall GadToolsBase 15;
+procedure GT_EndRefresh(Win: PWindow; Complete: LongInt); syscall GadToolsBase 16;
+function GT_FilterIMsg(const IMsg: PIntuiMessage): PIntuiMessage; syscall GadToolsBase 17;
+
+FUNCTION GT_GetIMsg(IPort: PMsgPort): PIntuiMessage; syscall GadToolsBase 12;
+FUNCTION GT_PostFilterIMsg(IMsg: PIntuiMessage): PIntuiMessage; syscall GadToolsBase 18;
+procedure GT_RefreshWindow(Win: PWindow; Req: PRequester); syscall GadToolsBase 14;
+procedure GT_ReplyIMsg(IMsg: PIntuiMessage); syscall GadToolsBase 13;
+function GT_GetGadgetAttrsA(Gad: PGadget; Win: PWindow; Req: PRequester; const TagList: PTagItem): LongInt; syscall GadToolsBase 29;
+procedure GT_SetGadgetAttrsA(Gad: PGadget; Win: PWindow; Req: PRequester; const TagList: PTagItem); syscall GadToolsBase 7;
+function LayoutMenuItemsA(FirstItem: PMenuItem; vi: Pointer; const TagList: PTagItem): LongBool; syscall GadToolsBase 10;
+function LayoutMenusA(FirstMenu: PMenu; vi: Pointer; const TagList: PTagItem): LongBool; syscall GadToolsBase 11;
+
+function GTMENUITEM_USERDATA(MenuItem: PMenuItem): Pointer;
+function GTMENU_USERDATA(Menu: PMenu): Pointer;
+
+
+implementation
+
+function GTMENUITEM_USERDATA(menuitem : pMenuItem): pointer;
+begin
+  GTMENUITEM_USERDATA := Pointer((PMenuItem(MenuItem) + 1));
+end;
+
+function GTMENU_USERDATA(Menu: PMenu): Pointer;
+begin
+  GTMENU_USERDATA := Pointer((PMenu(Menu) + 1));
+end;
+
+initialization
+  GadToolsBase := OpenLibrary('gadtools.library', 36);
+finalization
+  CloseLibrary(GadToolsBase);
+end. 
+
+
+
+

+ 3894 - 0
packages/arosunits/src/mui.pas

@@ -0,0 +1,3894 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2014 by Free Pascal development team
+
+    ZUNE/MUI functions
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+{$mode objfpc}
+{$packrecords C}
+unit mui;
+
+interface
+
+  {
+
+     MUI - MagicUserInterface
+     (c) 1993-1997 Stefan Stuntz
+
+     Main Header File
+
+
+     Class Tree
+
+
+     rootclass                    (BOOPSI's base class)
+     +--Notify                   (implements notification mechanism)
+     !  +--Family                (handles multiple children)
+     !  !  +--Menustrip          (describes a complete menu strip)
+     !  !  +--Menu               (describes a single menu)
+     !  !  \--Menuitem           (describes a single menu item)
+     !  +--Application           (main class for all applications)
+     !  +--Window                (main class for all windows)
+     !  !  \--Aboutmui           (About window of MUI preferences)
+     !  +--Area                  (base class for all GUI elements)
+     !     +--Rectangle          (spacing object)
+     !     +--Balance            (balancing separator bar)
+     !     +--Image              (image display)
+     !     +--Bitmap             (draws bitmaps)
+     !     !  \--Bodychunk       (makes bitmap from ILBM body chunk)
+     !     +--Text               (text display)
+     !     +--Gadget             (base class for intuition gadgets)
+     !     !  +--String          (string gadget)
+     !     !  +--Boopsi          (interface to BOOPSI gadgets)
+     !     !  \--Prop            (proportional gadget)
+     !     +--Gauge              (fule gauge)
+     !     +--Scale              (percentage scale)
+     !     +--Colorfield         (field with changeable color)
+     !     +--List               (line-oriented list)
+     !     !  +--Floattext       (special list with floating text)
+     !     !  +--Volumelist      (special list with volumes)
+     !     !  +--Scrmodelist     (special list with screen modes)
+     !     !  \--Dirlist         (special list with files)
+     !     +--Numeric            (base class for slider gadgets)
+     !     !  +--Knob            (turning knob)
+     !     !  +--Levelmeter      (level display)
+     !     !  +--Numericbutton   (space saving popup slider)
+     !     !  \--Slider          (traditional slider)
+     !     +--Framedisplay       (private)
+     !     !  \--Popframe        (private)
+     !     +--Imagedisplay       (private)
+     !     !  \--Popimage        (private)
+     !     +--Pendisplay         (displays a pen specification)
+     !     !  \--Poppen          (popup button to adjust a pen spec)
+     !     +--Group              (groups other GUI elements)
+     !        +--Mccprefs        (private)
+     !        +--Register        (handles page groups with titles)
+     !        !  \--Penadjust    (group to adjust a pen)
+     !        +--Settingsgroup   (private)
+     !        +--Settings        (private)
+     !        +--Frameadjust     (private)
+     !        +--Imageadjust     (private)
+     !        +--Virtgroup       (handles virtual groups)
+     !        +--Scrollgroup     (virtual groups with scrollbars)
+     !        +--Scrollbar       (traditional scrollbar)
+     !        +--Listview        (listview)
+     !        +--Radio           (radio button)
+     !        +--Cycle           (cycle gadget)
+     !        +--Coloradjust     (several gadgets to adjust a color)
+     !        +--Palette         (complete palette gadget)
+     !        +--Popstring       (base class for popup objects)
+     !           +--Popobject    (popup aynthing in a separate window)
+     !           !  +--Poplist   (popup a simple listview)
+     !           !  \--Popscreen (popup a list of public screens)
+     !           \--Popasl       (popup an asl requester)
+     +--Semaphore                (semaphore equipped objects)
+        +--Applist               (private)
+        +--Dataspace             (handles general purpose data spaces)
+           \--Configdata         (private)
+
+
+     General Header File Information
+
+
+     All macro and structure definitions follow these rules:
+
+     Name                       Meaning
+
+     MUIC_<class>               Name of a class
+     MUIM_<class>_<method>      Method
+     MUIP_<class>_<method>      Methods parameter structure
+     MUIV_<class>_<method>_<x>  Special method value
+     MUIA_<class>_<attrib>      Attribute
+     MUIV_<class>_<attrib>_<x>  Special attribute value
+     MUIE_<error>               Error return code from MUI_Error()
+     MUII_<name>                Standard MUI image
+     MUIX_<code>                Control codes for text strings
+     MUIO_<name>                Object type for MUI_MakeObject()
+
+     MUIA_... attribute definitions are followed by a comment
+     consisting of the three possible letters I, S and G.
+     I: it's possible to specify this attribute at object creation time.
+     S: it's possible to change this attribute with SetAttrs().
+     G: it's possible to get this attribute with GetAttr().
+
+     Items marked with "Custom Class" are for use in custom classes only!
+   }
+
+uses
+  exec, intuition,utility,agraphics{,iffparse};
+
+
+  const
+     MUIMASTER_NAME: PChar = 'muimaster.library';
+     MUIMASTER_VMIN = 11;
+     MUIMASTER_VLATEST = 19;
+  {
+     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+     Warning, some of the macros in this header file work only with
+     muimaster.library V11 and above. If you recompile your programs,
+     be sure to open muimaster.library with MUIMASTER_VMIN as version number.
+     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+   }
+
+  {
+     Config items for MUIM_GetConfigItem
+                                                                           }
+     MUICFG_PublicScreen = 36;
+  {
+     Black box specification structures for images, pens, frames
+                                                                           }
+
+  type
+     Plongword = ^LongWord;
+
+     TMUI_PenSpec = record
+          Buf: array[0..31] of Char;
+     End;
+     PMUI_PenSpec = ^TMUI_PenSpec;
+
+  {
+     Public Screen Stuff
+                                                                           }
+  {
+     NOTE: This stuff is only included to allow compilation of the supplied
+           public screen manager for educational purposes. Everything
+           here is subject to change without notice and I guarantee to
+           do that just for fun!
+           More info can be found in the screen manager source file.
+   }
+
+  const
+     PSD_INITIAL_NAME : PChar = '(unnamed)';
+     PSD_INITIAL_TITLE : PChar = 'MUI Public Screen';
+
+
+
+  const
+     PSD_NAME_FRONTMOST : PChar = '«Frontmost»';
+     PSD_FILENAME_SAVE : PChar = 'envarc:mui/PublicScreens.iff';
+     PSD_FILENAME_USE : PChar = 'env:mui/PublicScreens.iff';
+     PSD_MAXLEN_NAME = 32;
+     PSD_MAXLEN_TITLE = 128;
+     PSD_MAXLEN_FONT = 48;
+     PSD_MAXLEN_BACKGROUND = 256;
+     PSD_NUMCOLS = 8;
+     PSD_MAXSYSPENS = 20;
+     PSD_NUMSYSPENS = 12;
+     PSD_MAXMUIPENS = 10;
+     PSD_NUMMUIPENS = 8;
+
+  type
+     tMUI_RGBcolor = record
+          red : LongWord;
+          green : LongWord;
+          blue : LongWord;
+       end;
+
+     pMUI_RGBColor = ^tMUI_RGBColor;
+
+     tMUI_PubScreenDesc = record
+          Version : LONG;
+          Name : array[0..(PSD_MAXLEN_NAME)-1] of char;
+          Title : array[0..(PSD_MAXLEN_TITLE)-1] of char;
+          Font : array[0..(PSD_MAXLEN_FONT)-1] of char;
+          Background : array[0..(PSD_MAXLEN_BACKGROUND)-1] of char;
+          DisplayID : LongWord;
+          DisplayWidth : WORD;
+          DisplayHeight : WORD;
+          DisplayDepth : BYTE;
+          OverscanType : BYTE;
+          AutoScroll : BYTE;
+          NoDrag : BYTE;
+          Exclusive : BYTE;
+          Interleaved : BYTE;
+          SysDefault : BYTE;
+          Behind : BYTE;
+          AutoClose : BYTE;
+          CloseGadget : BYTE;
+          DummyWasForeign : BYTE;
+          SystemPens : array[0..(PSD_MAXSYSPENS)-1] of BYTE;
+          Reserved : array[0..((1 + (7 * 4)) - PSD_MAXSYSPENS)-1] of BYTE;
+          Palette : array[0..(PSD_NUMCOLS)-1] of tMUI_RGBcolor;
+          rsvd : array[0..(PSD_MAXSYSPENS - PSD_NUMCOLS)-1] of tMUI_RGBcolor;
+          rsvd2 : array[0..(PSD_MAXMUIPENS)-1] of tMUI_PenSpec;
+          Changed : LONG;
+          UserData : APTR;
+       end;
+     pMUI_PubScreenDesc = ^tMUI_PubScreenDesc;
+
+     tMUIS_InfoClient = record
+          node : tMinNode;
+          task : PTask;
+          sigbit : LongWord;
+       end;
+     pMUIS_InfoClient = ^tMUIS_InfoClient;
+
+  {
+     Object Types for MUI_MakeObject()
+                                                                             }
+  { STRPTR label, LongWord flags  }
+
+  const
+
+     MUIO_Label = 1;
+  { STRPTR label  }
+     MUIO_Button = 2;
+  { STRPTR label  }
+     MUIO_Checkmark = 3;
+  { STRPTR label, STRPTR  entries  }
+     MUIO_Cycle = 4;
+  { STRPTR label, STRPTR  entries  }
+     MUIO_Radio = 5;
+  { STRPTR label, LONG min, LONG max  }
+     MUIO_Slider = 6;
+  { STRPTR label, LONG maxlen  }
+     MUIO_String = 7;
+  { STRPTR imagespec  }
+     MUIO_PopButton = 8;
+  { LONG space    }
+     MUIO_HSpace = 9;
+  { LONG space    }
+     MUIO_VSpace = 10;
+  { LONG space    }
+     MUIO_HBar = 11;
+  { LONG space    }
+     MUIO_VBar = 12;
+  { struct NewMenu  nm, LongWord flags  }
+     MUIO_MenustripNM = 13;
+  { STRPTR label, STRPTR shortcut, LongWord flags, LongWord data   }
+     MUIO_Menuitem = 14;
+  { STRPTR label  }
+     MUIO_BarTitle = 15;
+  { STRPTR label, LONG min, LONG max, STRPTR format  }
+     MUIO_NumericButton = 16;
+     MUIO_Menuitem_CopyStrings = 1 shl 30;
+     MUIO_Label_SingleFrame = 1 shl 8;
+     MUIO_Label_DoubleFrame = 1 shl 9;
+     MUIO_Label_LeftAligned = 1 shl 10;
+     MUIO_Label_Centered = 1 shl 11;
+     MUIO_Label_FreeVert = 1 shl 12;
+  { check for "localized" menu items such as "O\0Open"  }
+     MUIO_MenustripNM_CommandKeyCheck = 1 shl 0;
+  {
+     ARexx Interface
+                                                                             }
+
+  type
+     tMUI_Command = record
+          mc_Name : Pchar;
+          mc_Template : Pchar;
+          mc_Parameters : LONG;
+          mc_Hook : PHook;
+          mc_Reserved : array[0..4] of LONG;
+       end;
+     pMUI_Command = ^tMUI_Command;
+
+
+
+    const
+     {  MC_TEMPLATE_ID : PCHar = not(0); }
+       MC_TEMPLATE_ID  = -1;
+       MUI_RXERR_BADDEFINITION = -(1);
+       MUI_RXERR_OUTOFMEMORY = -(2);
+       MUI_RXERR_UNKNOWNCOMMAND = -(3);
+       MUI_RXERR_BADSYNTAX = -(4);
+    {
+       Return values for MUI_Error()
+                                                                               }
+       MUIE_OK = 0;
+       MUIE_OutOfMemory = 1;
+       MUIE_OutOfGfxMemory = 2;
+       MUIE_InvalidWindowObject = 3;
+       MUIE_MissingLibrary = 4;
+       MUIE_NoARexx = 5;
+       MUIE_SingleTask = 6;
+    {
+       Standard MUI Images & Backgrounds
+                                                                               }
+    { These images are configured    }
+       MUII_WindowBack = 0;
+    { with the preferences program.  }
+       MUII_RequesterBack = 1;
+       MUII_ButtonBack = 2;
+       MUII_ListBack = 3;
+       MUII_TextBack = 4;
+       MUII_PropBack = 5;
+       MUII_PopupBack = 6;
+       MUII_SelectedBack = 7;
+       MUII_ListCursor = 8;
+       MUII_ListSelect = 9;
+       MUII_ListSelCur = 10;
+       MUII_ArrowUp = 11;
+       MUII_ArrowDown = 12;
+       MUII_ArrowLeft = 13;
+       MUII_ArrowRight = 14;
+       MUII_CheckMark = 15;
+       MUII_RadioButton = 16;
+       MUII_Cycle = 17;
+       MUII_PopUp = 18;
+       MUII_PopFile = 19;
+       MUII_PopDrawer = 20;
+       MUII_PropKnob = 21;
+       MUII_Drawer = 22;
+       MUII_HardDisk = 23;
+       MUII_Disk = 24;
+       MUII_Chip = 25;
+       MUII_Volume = 26;
+       MUII_RegisterBack = 27;
+       MUII_Network = 28;
+       MUII_Assign = 29;
+       MUII_TapePlay = 30;
+       MUII_TapePlayBack = 31;
+       MUII_TapePause = 32;
+       MUII_TapeStop = 33;
+       MUII_TapeRecord = 34;
+       MUII_GroupBack = 35;
+       MUII_SliderBack = 36;
+       MUII_SliderKnob = 37;
+       MUII_TapeUp = 38;
+       MUII_TapeDown = 39;
+       MUII_PageBack = 40;
+       MUII_ReadListBack = 41;
+       MUII_Count = 42;
+    { These are direct color     }
+       MUII_BACKGROUND = 128;
+    { combinations and are not   }
+       MUII_SHADOW = 129;
+    { affected by users prefs.   }
+       MUII_SHINE = 130;
+       MUII_FILL = 131;
+    { Generally, you should      }
+       MUII_SHADOWBACK = 132;
+    { avoid using them. Better   }
+       MUII_SHADOWFILL = 133;
+    { use one of the customized  }
+       MUII_SHADOWSHINE = 134;
+    { images above.              }
+       MUII_FILLBACK = 135;
+       MUII_FILLSHINE = 136;
+       MUII_SHINEBACK = 137;
+       MUII_FILLBACK2 = 138;
+       MUII_HSHINEBACK = 139;
+       MUII_HSHADOWBACK = 140;
+       MUII_HSHINESHINE = 141;
+       MUII_HSHADOWSHADOW = 142;
+       MUII_MARKSHINE = 143;
+       MUII_MARKHALFSHINE = 144;
+       MUII_MARKBACKGROUND = 145;
+       MUII_LASTPAT = 145;
+    {
+       Special values for some methods
+                                                                               }
+       MUIV_TriggerValue = $49893131;
+       MUIV_NotTriggerValue = $49893133;
+       MUIV_EveryTime = $49893131;
+       MUIV_Notify_Self = 1;
+       MUIV_Notify_Window = 2;
+       MUIV_Notify_Application = 3;
+       MUIV_Notify_Parent = 4;
+
+
+    const
+       MUIV_Application_ReturnID_Quit = -(1);
+       MUIV_List_Insert_Top = 0;
+       MUIV_List_Insert_Active = -(1);
+       MUIV_List_Insert_Sorted = -(2);
+       MUIV_List_Insert_Bottom = -(3);
+       MUIV_List_Remove_First = 0;
+       MUIV_List_Remove_Active = -(1);
+       MUIV_List_Remove_Last = -(2);
+       MUIV_List_Remove_Selected = -(3);
+       MUIV_List_Select_Off = 0;
+       MUIV_List_Select_On = 1;
+       MUIV_List_Select_Toggle = 2;
+       MUIV_List_Select_Ask = 3;
+       MUIV_List_GetEntry_Active = -(1);
+       MUIV_List_Select_Active = -(1);
+       MUIV_List_Select_All = -(2);
+       MUIV_List_Redraw_Active = -(1);
+       MUIV_List_Redraw_All = -(2);
+       MUIV_List_Move_Top = 0;
+       MUIV_List_Move_Active = -(1);
+       MUIV_List_Move_Bottom = -(2);
+    { only valid for second parameter  }
+       MUIV_List_Move_Next = -(3);
+    { only valid for second parameter  }
+       MUIV_List_Move_Previous = -(4);
+       MUIV_List_Exchange_Top = 0;
+       MUIV_List_Exchange_Active = -(1);
+       MUIV_List_Exchange_Bottom = -(2);
+    { only valid for second parameter  }
+       MUIV_List_Exchange_Next = -(3);
+    { only valid for second parameter  }
+       MUIV_List_Exchange_Previous = -(4);
+       MUIV_List_Jump_Top = 0;
+       MUIV_List_Jump_Active = -(1);
+       MUIV_List_Jump_Bottom = -(2);
+       MUIV_List_Jump_Up = -(4);
+       MUIV_List_Jump_Down = -(3);
+       MUIV_List_NextSelected_Start = -(1);
+       MUIV_List_NextSelected_End = -(1);
+       MUIV_DragQuery_Refuse = 0;
+       MUIV_DragQuery_Accept = 1;
+       MUIV_DragReport_Abort = 0;
+       MUIV_DragReport_Continue = 1;
+       MUIV_DragReport_Lock = 2;
+       MUIV_DragReport_Refresh = 3;
+    {
+       Control codes for text strings
+                                                                               }
+    { right justified  }
+       MUIX_R : PChar = '\033r';
+    { centered         }
+       MUIX_C : PChar = '\033c';
+    { left justified   }
+       MUIX_L : PChar = '\033l';
+    { normal      }
+       MUIX_N : PChar = '\033n';
+    { bold        }
+       MUIX_B : PChar = '\033b';
+    { italic      }
+       MUIX_I : PChar = '\033i';
+    { underlined  }
+       MUIX_U : PChar = '\033u';
+    { text pen            }
+       MUIX_PT : PChar = '\0332';
+    { highlight text pen  }
+       MUIX_PH : PChar = '\0338';
+    {
+       Parameter structures for some classes
+                                                                               }
+
+    type
+       tMUI_Palette_Entry = record
+            mpe_ID : LONG;
+            mpe_Red : LongWord;
+            mpe_Green : LongWord;
+            mpe_Blue : LongWord;
+            mpe_Group : LONG;
+         end;
+       pMUI_Palette_Entry = ^tMUI_Palette_Entry;
+
+    const
+       MUIV_Palette_Entry_End = (-1);
+    {                            }
+    { Application Input Handler  }
+    {                            }
+    { see below  }
+
+    type
+       tMUI_InputHandlerNode = record
+            ihn_Node : tMinNode;
+            ihn_Object : PObject_;
+            ihn_stuff : record
+                case LongInt of
+                   0 : ( ihn_sigs : LongWord );
+                   1 : ( ihn_timer : record
+                        ihn_millis : WORD;
+                        ihn_current : WORD;
+                     end );
+                end;
+            ihn_Flags : LongWord;
+            ihn_Method : LongWord;
+         end;
+    pMUI_InputHandlerNode = ^tMUI_InputHandlerNode;
+
+    const
+      { ihn_Signals = ihn_stuff.ihn_sigs;
+       ihn_Millis = ihn_stuff.(ihn_timer.ihn_millis);
+       ihn_Current = ihn_stuff.(ihn_timer.ihn_current); }
+    { Flags for ihn_Flags  }
+    { set ihn_Ticks to number of 1/100 sec ticks you want to be triggered  }
+       MUIIHNF_TIMER = 1 shl 0;
+    {                       }
+    { Window Event Handler  }
+    {                       }
+    { don't touch!  }
+    { event handlers are inserted according to their priority.  }
+    { certain flags, see below for definitions.  }
+    { object which should receive MUIM_HandleEvent.  }
+    { if !=NULL, MUIM_HandleEvent is invoked on exactly this class with CoerceMethod().  }
+    { one or more IDCMP flags this handler should react on.  }
+
+    type
+
+{       BinCompat Mode?
+         tMUI_EventHandlerNode = record
+            ehn_Node : tMinNode;
+            ehn_Reserved : BYTE;
+            ehn_Priority : BYTE;
+            ehn_Flags : WORD;
+            ehn_Object : PObject_;
+            ehn_Class : PIClass;
+            ehn_Events : LongWord;
+         end;}
+       tMUI_EventHandlerNode = record
+            ehn_Node : tMinNode;
+            ehn_Flags : WORD;
+            ehn_Object : PObject_;
+            ehn_Class : PIClass;
+            ehn_Events : LongWord;
+            ehn_Priority : BYTE;            
+         end;
+       pMUI_EventHandlerNode = ^tMUI_EventHandlerNode;
+    { flags for ehn_Flags  }
+
+    const
+       MUI_EHF_ALWAYSKEYS = 1 shl 0;
+    { other values reserved for future use  }
+    { return values for MUIM_HandleEvent (bit-masked, all other bits must be 0)  }
+    { stop MUI from calling other handlers  }
+       MUI_EventHandlerRC_Eat = 1 shl 0;
+    {                     }
+    { List Position Test  }
+    {                     }
+    { number of entry, -1 if mouse not over valid entry  }
+    { numer of column, -1 if no valid column  }
+    { see below  }
+    { x offset of mouse click relative to column start  }
+    { y offset of mouse click from center of line
+                          (negative values mean click was above center,
+                           positive values mean click was below center)  }
+
+    type
+       tMUI_List_TestPos_Result = record
+            entry : LONG;
+            column : WORD;
+            flags : WORD;
+            xoffset : WORD;
+            yoffset : WORD;
+         end;
+       pMUI_List_TestPos_Result = ^tMUI_List_TestPos_Result;
+
+    const
+       MUI_LPR_ABOVE = 1 shl 0;
+       MUI_LPR_BELOW = 1 shl 1;
+       MUI_LPR_LEFT = 1 shl 2;
+       MUI_LPR_RIGHT = 1 shl 3;
+
+    {
+
+       For Boopsi Image Implementors Only:
+
+       If MUI is using a boopsi image object, it will send a special method
+       immediately after object creation. This method has a parameter structure
+       where the boopsi can fill in its minimum and maximum size and learn if
+       its used in a horizontal or vertical context.
+
+       The boopsi image must use the method id (MUIM_BoopsiQuery) as return
+       value. That's how MUI sees that the method is implemented.
+
+       Note: MUI does not depend on this method. If the boopsi image doesn't
+             implement it, minimum size will be 0 and maximum size unlimited.
+
+                                                                               }
+    { this is send to the boopsi and  }
+
+    const
+       MUIM_BoopsiQuery = $80427157;
+    { must be used as return value    }
+    { parameter structure  }
+    { always MUIM_BoopsiQuery  }
+    { obsolete, use mbq_RenderInfo  }
+    { read only, see below  }
+    { write only, fill in min width   }
+    { write only, fill in min height  }
+    { write only, fill in max width   }
+    { write only, fill in max height  }
+    { write only, fill in def width   }
+    { write only, fill in def height  }
+    { read only, display context  }
+    { may grow in future ...  }
+
+ type
+       tMUI_RenderInfo = record
+            mri_WindowObject : PObject_;
+            mri_Screen : PScreen;
+            mri_DrawInfo : PDrawInfo;
+            mri_Pens : ^WORD;
+            mri_Window : PWindow;
+            mri_RastPort : PRastPort;
+            mri_Flags : LongWord;
+         end;
+       PMUI_RenderInfo = ^tMUI_RenderInfo;
+
+    type
+       tMUI_BoopsiQuery = record
+            mbq_MethodID : LongWord;
+            mbq_Screen : PScreen;
+            mbq_Flags : LongWord;
+            mbq_MinWidth : LONG;
+            mbq_MinHeight : LONG;
+            mbq_MaxWidth : LONG;
+            mbq_MaxHeight : LONG;
+            mbq_DefWidth : LONG;
+            mbq_DefHeight : LONG;
+            mbq_RenderInfo : PMUI_RenderInfo;
+         end;
+       pMUI_BoopsiQuery = ^tMUI_BoopsiQuery;
+    { old structure name  }
+
+
+       MUIP_BoopsiQuery = tMUI_BoopsiQuery;
+
+     const
+    { object used in a horizontal  }
+       MBQF_HORIZ = 1 shl 0;
+    { context (else vertical)      }
+    { use this for unlimited MaxWidth/Height  }
+       MBQ_MUI_MAXMAX = 10000;
+    {                                          }
+    { Begin of automatic header file creation  }
+    {                                          }
+    {                                                                           }
+    {  Notify                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Notify : PChar = 'Notify.mui';
+
+    { Methods  }
+    { V4   }
+
+    const
+       MUIM_CallHook = $8042b96b;
+    { V12  }
+       MUIM_Export = $80420f1c;
+    { V8   }
+       MUIM_FindUData = $8042c196;
+    { V11  }
+       MUIM_GetConfigItem = $80423edb;
+    { V8   }
+       MUIM_GetUData = $8042ed0c;
+    { V12  }
+       MUIM_Import = $8042d012;
+    { V4   }
+       MUIM_KillNotify = $8042d240;
+    { V16  }
+       MUIM_KillNotifyObj = $8042b145;
+    { V7   }
+       MUIM_MultiSet = $8042d356;
+    { V9   }
+       MUIM_NoNotifySet = $8042216f;
+    { V4   }
+       MUIM_Notify = $8042c9cb;
+    { V4   }
+       MUIM_Set = $8042549a;
+    { V4   }
+       MUIM_SetAsString = $80422590;
+    { V8   }
+       MUIM_SetUData = $8042c920;
+    { V11  }
+       MUIM_SetUDataOnce = $8042ca19;
+    { V6   }
+       MUIM_WriteLong = $80428d86;
+    { V6   }
+       MUIM_WriteString = $80424bf4;
+    { ...  }
+
+    type
+       tMUIP_CallHook = record
+            MethodID : LongWord;
+            Hook : PHook;
+            param1 : LongWord;
+         end;
+       pMUIP_CallHook = ^tMUIP_CallHook;
+
+       tMUIP_Export = record
+            MethodID : LongWord;
+            dataspace : PObject_;
+         end;
+       pMUIP_Export = ^tMUIP_Export;
+
+       tMUIP_FindUData = record
+            MethodID : LongWord;
+            udata : LongWord;
+         end;
+       pMUIP_FindUData = ^tMUIP_FindUData;
+
+       tMUIP_GetConfigItem = record
+            MethodID : LongWord;
+            id : LongWord;
+            storage : PLongWord;
+         end;
+       pMUIP_GetConfigItem = ^tMUIP_GetConfigItem;
+
+       tMUIP_GetUData = record
+            MethodID : LongWord;
+            udata : LongWord;
+            attr : LongWord;
+            storage : PLongWord;
+         end;
+       pMUIP_GetUData = ^tMUIP_GetUData;
+
+       tMUIP_Import = record
+            MethodID : LongWord;
+            dataspace : PObject_;
+         end;
+       pMUIP_Import = ^tMUIP_Import;
+
+       tMUIP_KillNotify = record
+            MethodID : LongWord;
+            TrigAttr : LongWord;
+         end;
+       pMUIP_KillNotify = ^tMUIP_KillNotify;
+
+       tMUIP_KillNotifyObj = record
+            MethodID : LongWord;
+            TrigAttr : LongWord;
+            dest : PObject_;
+         end;
+       pMUIP_KillNotifyObj = ^tMUIP_KillNotifyObj;
+
+    { ...  }
+       tMUIP_MultiSet = record
+            MethodID : LongWord;
+            attr : LongWord;
+            val : LongWord;
+            obj : APTR;
+         end;
+       pMUIP_MultiSet = ^tMUIP_MultiSet;
+
+    { ...  }
+       tMUIP_NoNotifySet = record
+            MethodID : LongWord;
+            attr : LongWord;
+            format : Pchar;
+            val : LongWord;
+         end;
+       pMUIP_NoNotifySet = ^tMUIP_NoNotifySet;
+
+    { ...  }
+       tMUIP_Notify = record
+            MethodID : LongWord;
+            TrigAttr : LongWord;
+            TrigVal : LongWord;
+            DestObj : APTR;
+            FollowParams : LongWord;
+         end;
+       pMUIP_Notify = ^tMUIP_Notify;
+
+       tMUIP_Set = record
+            MethodID : LongWord;
+            attr : LongWord;
+            val : LongWord;
+         end;
+       pMUIP_Set = ^tMUIP_Set;
+
+    { ...  }
+       tMUIP_SetAsString = record
+            MethodID : LongWord;
+            attr : LongWord;
+            format : Pchar;
+            val : LongWord;
+         end;
+       pMUIP_SetAsString = ^tMUIP_SetAsString;
+
+       tMUIP_SetUData = record
+            MethodID : LongWord;
+            udata : LongWord;
+            attr : LongWord;
+            val : LongWord;
+         end;
+       pMUIP_SetUData = ^tMUIP_SetUData;
+
+       tMUIP_SetUDataOnce = record
+            MethodID : LongWord;
+            udata : LongWord;
+            attr : LongWord;
+            val : LongWord;
+         end;
+       pMUIP_SetUDataOnce = ^tMUIP_SetUDataOnce;
+
+       tMUIP_WriteLong = record
+            MethodID : LongWord;
+            val : LongWord;
+            memory : PLongWord;
+         end;
+       pMUIP_WriteLong = ^tMUIP_WriteLong;
+
+       tMUIP_WriteString = record
+            MethodID : LongWord;
+            str : Pchar;
+            memory : Pchar;
+         end;
+       pMUIP_WriteString = ^tMUIP_WriteString;
+
+    { Attributes  }
+    { V4  ..g Object             }
+
+    const
+       MUIA_ApplicationObject = $8042d3ee;
+    { V5  ..g struct AppMessage    }
+       MUIA_AppMessage = $80421955;
+    { V4  isg LONG               }
+       MUIA_HelpLine = $8042a825;
+    { V4  isg STRPTR             }
+       MUIA_HelpNode = $80420b85;
+    { V7  .s. BOOL               }
+       MUIA_NoNotify = $804237f9;
+    { V11 isg LongWord              }
+       MUIA_ObjectID = $8042d76e;
+    { V11 ..g Object             }
+       MUIA_Parent = $8042e35f;
+    { V4  ..g LONG               }
+       MUIA_Revision = $80427eaa;
+    { V4  isg LongWord              }
+       MUIA_UserData = $80420313;
+    { V4  ..g LONG               }
+       MUIA_Version = $80422301;
+    {                                                                           }
+    {  Family                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Family : PChar = 'Family.mui';
+
+    { Methods  }
+    { V8   }
+
+    const
+       MUIM_Family_AddHead = $8042e200;
+    { V8   }
+       MUIM_Family_AddTail = $8042d752;
+    { V8   }
+       MUIM_Family_Insert = $80424d34;
+    { V8   }
+       MUIM_Family_Remove = $8042f8a9;
+    { V8   }
+       MUIM_Family_Sort = $80421c49;
+    { V8   }
+       MUIM_Family_Transfer = $8042c14a;
+
+    type
+       tMUIP_Family_AddHead = record
+            MethodID : LongWord;
+            obj : PObject_;
+         end;
+       pMUIP_Family_AddHead = ^tMUIP_Family_AddHead;
+
+       tMUIP_Family_AddTail = record
+            MethodID : LongWord;
+            obj : PObject_;
+         end;
+       pMUIP_Family_AddTail = ^tMUIP_Family_AddTail;
+
+       tMUIP_Family_Insert = record
+            MethodID : LongWord;
+            obj : PObject_;
+            pred : PObject_;
+         end;
+       pMUIP_Family_Insert = ^tMUIP_Family_Insert;
+
+       tMUIP_Family_Remove = record
+            MethodID : LongWord;
+            obj : PObject_;
+         end;
+       pMUIP_Family_Remove = ^tMUIP_Family_Remove;
+
+       tMUIP_Family_Sort = record
+            MethodID : LongWord;
+            obj : array[0..0] of PObject_;
+         end;
+       pMUIP_Family_Sort = ^tMUIP_Family_Sort;
+
+       tMUIP_Family_Transfer = record
+            MethodID : LongWord;
+            family : PObject_;
+         end;
+       pMUIP_Family_Transfer = ^tMUIP_Family_Transfer;
+
+    { Attributes  }
+    { V8  i.. Object             }
+
+    const
+       MUIA_Family_Child = $8042c696;
+    { V8  ..g struct MinList     }
+       MUIA_Family_List = $80424b9e;
+    {                                                                           }
+    {  Menustrip                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Menustrip : PChar = 'Menustrip.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V8  isg BOOL               }
+
+    const
+       MUIA_Menustrip_Enabled = $8042815b;
+    {                                                                           }
+    {  Menu                                                                     }
+    {                                                                           }
+
+
+    const
+       MUIC_Menu : PChar = 'Menu.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V8  isg BOOL               }
+
+    const
+       MUIA_Menu_Enabled = $8042ed48;
+    { V8  isg STRPTR             }
+       MUIA_Menu_Title = $8042a0e3;
+    {                                                                           }
+    {  Menuitem                                                                 }
+    {                                                                           }
+
+
+    const
+       MUIC_Menuitem : PChar = 'Menuitem.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V8  isg BOOL               }
+
+    const
+       MUIA_Menuitem_Checked = $8042562a;
+    { V8  isg BOOL               }
+       MUIA_Menuitem_Checkit = $80425ace;
+    { V16 isg BOOL               }
+       MUIA_Menuitem_CommandString = $8042b9cc;
+    { V8  isg BOOL               }
+       MUIA_Menuitem_Enabled = $8042ae0f;
+    { V8  isg LONG               }
+       MUIA_Menuitem_Exclude = $80420bc6;
+    { V8  isg STRPTR             }
+       MUIA_Menuitem_Shortcut = $80422030;
+    { V8  isg STRPTR             }
+       MUIA_Menuitem_Title = $804218be;
+    { V8  isg BOOL               }
+       MUIA_Menuitem_Toggle = $80424d5c;
+    { V8  ..g struct MenuItem    }
+       MUIA_Menuitem_Trigger = $80426f32;
+       MUIV_Menuitem_Shortcut_Check = -(1);
+    {                                                                           }
+    {  Application                                                              }
+    {                                                                           }
+
+
+    const
+       MUIC_Application : PChar = 'Application.mui';
+
+    { Methods  }
+    { V14  }
+
+    const
+       MUIM_Application_AboutMUI = $8042d21d;
+    { V11  }
+       MUIM_Application_AddInputHandler = $8042f099;
+    { V11  }
+       MUIM_Application_CheckRefresh = $80424d68;
+
+    { MUI_OBSOLETE  }
+    { V4   }
+
+    const
+       MUIM_Application_InputBuffered = $80427e59;
+    { V4   }
+       MUIM_Application_Load = $8042f90d;
+    { V11  }
+       MUIM_Application_NewInput = $80423ba6;
+    { V11  }
+       MUIM_Application_OpenConfigWindow = $804299ba;
+    { V4   }
+       MUIM_Application_PushMethod = $80429ef8;
+    { V11  }
+       MUIM_Application_RemInputHandler = $8042e7af;
+    { V4   }
+       MUIM_Application_ReturnID = $804276ef;
+    { V4   }
+       MUIM_Application_Save = $804227ef;
+    { V11  }
+       MUIM_Application_SetConfigItem = $80424a80;
+
+    { V4   }
+
+    const
+       MUIM_Application_ShowHelp = $80426479;
+
+    type
+       tMUIP_Application_AboutMUI = record
+            MethodID : LongWord;
+            refwindow : PObject_;
+         end;
+       pMUIP_Application_AboutMUI = ^tMUIP_Application_AboutMUI;
+
+       tMUIP_Application_AddInputHandler = record
+            MethodID : LongWord;
+            ihnode : PMUI_InputHandlerNode;
+         end;
+       pMUIP_Application_AddInputHandler = ^tMUIP_Application_AddInputHandler;
+
+       tMUIP_Application_CheckRefresh = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Application_CheckRefresh = ^tMUIP_Application_CheckRefresh;
+
+       tMUIP_Application_GetMenuCheck = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+         end;
+       pMUIP_Application_GetMenuCheck = ^tMUIP_Application_GetMenuCheck;
+
+       tMUIP_Application_GetMenuState = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+         end;
+       pMUIP_Application_GetMenuState = ^tMUIP_Application_GetMenuState;
+
+       tMUIP_Application_Input = record
+            MethodID : LongWord;
+            signal : PLONGBITS;
+         end;
+       pMUIP_Application_Input = ^tMUIP_Application_Input;
+
+       tMUIP_Application_InputBuffered = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Application_InputBuffered = ^tMUIP_Application_InputBuffered;
+
+       tMUIP_Application_Load = record
+            MethodID : LongWord;
+            name : STRPTR;
+         end;
+
+       tMUIP_Application_NewInput = record
+            MethodID : LongWord;
+            signal : PLONGBITS;
+         end;
+       pMUIP_Application_NewInput = ^tMUIP_Application_NewInput;
+
+       tMUIP_Application_OpenConfigWindow = record
+            MethodID : LongWord;
+            flags : LongWord;
+         end;
+       pMUIP_Application_OpenConfigWindow = ^tMUIP_Application_OpenConfigWindow;
+
+    { ...  }
+       tMUIP_Application_PushMethod = record
+            MethodID : LongWord;
+            dest : PObject_;
+            count : LONG;
+         end;
+       pMUIP_Application_PushMethod = ^tMUIP_Application_PushMethod;
+
+       tMUIP_Application_RemInputHandler = record
+            MethodID : LongWord;
+            ihnode : PMUI_InputHandlerNode;
+         end;
+       pMUIP_Application_RemInputHandler = ^tMUIP_Application_RemInputHandler;
+
+       tMUIP_Application_ReturnID = record
+            MethodID : LongWord;
+            retid : LongWord;
+         end;
+       pMUIP_Application_ReturnID = ^tMUIP_Application_ReturnID;
+
+       tMUIP_Application_Save = record
+            MethodID : LongWord;
+            name : STRPTR;
+         end;
+
+       tMUIP_Application_SetConfigItem = record
+            MethodID : LongWord;
+            item : LongWord;
+            data : APTR;
+         end;
+       pMUIP_Application_SetConfigItem = ^tMUIP_Application_SetConfigItem;
+
+       tMUIP_Application_SetMenuCheck = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+            stat : LONG;
+         end;
+       pMUIP_Application_SetMenuCheck = ^tMUIP_Application_SetMenuCheck;
+
+       tMUIP_Application_SetMenuState = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+            stat : LONG;
+         end;
+       pMUIP_Application_SetMenuState = ^tMUIP_Application_SetMenuState;
+
+       tMUIP_Application_ShowHelp = record
+            MethodID : LongWord;
+            window : PObject_;
+            name : Pchar;
+            node : Pchar;
+            line : LONG;
+         end;
+       pMUIP_Application_ShowHelp = ^tMUIP_Application_ShowHelp;
+
+    { Attributes  }
+    { V4  isg BOOL               }
+
+    const
+       MUIA_Application_Active = $804260ab;
+    { V4  i.g STRPTR             }
+       MUIA_Application_Author = $80424842;
+    { V4  i.g STRPTR             }
+       MUIA_Application_Base = $8042e07a;
+    { V4  ..g Broker             }
+       MUIA_Application_Broker = $8042dbce;
+    { V4  isg struct Hook        }
+       MUIA_Application_BrokerHook = $80428f4b;
+    { V6  ..g struct MsgPort     }
+       MUIA_Application_BrokerPort = $8042e0ad;
+    { V6  i.g LONG               }
+       MUIA_Application_BrokerPri = $8042c8d0;
+    { V4  isg struct MUI_Command    }
+       MUIA_Application_Commands = $80428648;
+    { V4  i.g STRPTR             }
+       MUIA_Application_Copyright = $8042ef4d;
+    { V4  i.g STRPTR             }
+       MUIA_Application_Description = $80421fc6;
+    { V4  isg struct DiskObject    }
+       MUIA_Application_DiskObject = $804235cb;
+    { V4  ..g BOOL               }
+       MUIA_Application_DoubleStart = $80423bc6;
+    { V5  is. Object             }
+       MUIA_Application_DropObject = $80421266;
+    { V8  ..g BOOL               }
+       MUIA_Application_ForceQuit = $804257df;
+    { V8  isg STRPTR             }
+       MUIA_Application_HelpFile = $804293f4;
+    { V4  .sg BOOL               }
+       MUIA_Application_Iconified = $8042a07f;
+
+
+    const
+       MUIA_Application_MenuAction = $80428961;
+    { V4  ..g LongWord              }
+       MUIA_Application_MenuHelp = $8042540b;
+    { V8  i.. Object             }
+       MUIA_Application_Menustrip = $804252d9;
+    { V7  isg struct Hook        }
+       MUIA_Application_RexxHook = $80427c42;
+    { V4  ..g struct RxMsg       }
+       MUIA_Application_RexxMsg = $8042fd88;
+    { V4  .s. STRPTR             }
+       MUIA_Application_RexxString = $8042d711;
+    { V4  i.. BOOL               }
+       MUIA_Application_SingleTask = $8042a2c8;
+    { V4  .s. BOOL               }
+       MUIA_Application_Sleep = $80425711;
+    { V4  i.g STRPTR             }
+       MUIA_Application_Title = $804281b8;
+    { V10 i.. BOOL               }
+       MUIA_Application_UseCommodities = $80425ee5;
+    { V10 i.. BOOL               }
+       MUIA_Application_UseRexx = $80422387;
+    { V4  i.g STRPTR             }
+       MUIA_Application_Version = $8042b33f;
+    { V4  i.. Object             }
+       MUIA_Application_Window = $8042bfe0;
+    { V13 ..g struct List        }
+       MUIA_Application_WindowList = $80429abe;
+       MUIV_Application_Package_NetConnect = $a3ff7b49;
+    {                                                                           }
+    {  Window                                                                   }
+    {                                                                           }
+
+    const
+       MUIC_Window : PChar = 'Window.mui';
+
+    { V16  }
+
+    const
+       MUIM_Window_AddEventHandler = $804203b7;
+
+    { V16  }
+
+    const
+       MUIM_Window_RemEventHandler = $8042679e;
+    { V4   }
+       MUIM_Window_ScreenToBack = $8042913d;
+    { V4   }
+       MUIM_Window_ScreenToFront = $804227a4;
+
+    { V11  }
+
+    const
+       MUIM_Window_Snapshot = $8042945e;
+    { V4   }
+       MUIM_Window_ToBack = $8042152e;
+    { V4   }
+       MUIM_Window_ToFront = $8042554f;
+
+    type
+       tMUIP_Window_AddEventHandler = record
+            MethodID : LongWord;
+            ehnode : PMUI_EventHandlerNode;
+         end;
+       pMUIP_Window_AddEventHandler = ^tMUIP_Window_AddEventHandler;
+
+       tMUIP_Window_GetMenuCheck = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+         end;
+       pMUIP_Window_GetMenuCheck = ^tMUIP_Window_GetMenuCheck;
+
+       tMUIP_Window_GetMenuState = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+         end;
+        pMUIP_Window_GetMenuState =  ^tMUIP_Window_GetMenuState;
+
+       tMUIP_Window_RemEventHandler = record
+            MethodID : LongWord;
+            ehnode : PMUI_EventHandlerNode;
+         end;
+       pMUIP_Window_RemEventHandler = ^tMUIP_Window_RemEventHandler;
+
+       tMUIP_Window_ScreenToBack = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Window_ScreenToBack = ^tMUIP_Window_ScreenToBack;
+
+       tMUIP_Window_ScreenToFront = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Window_ScreenToFront = ^tMUIP_Window_ScreenToFront;
+
+       tMUIP_Window_SetCycleChain = record
+            MethodID : LongWord;
+            obj : array[0..0] of PObject_;
+         end;
+       pMUIP_Window_SetCycleChain = ^tMUIP_Window_SetCycleChain;
+
+       tMUIP_Window_SetMenuCheck = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+            stat : LONG;
+         end;
+       pMUIP_Window_SetMenuCheck = ^tMUIP_Window_SetMenuCheck;
+
+       tMUIP_Window_SetMenuState = record
+            MethodID : LongWord;
+            MenuID : LongWord;
+            stat : LONG;
+         end;
+       pMUIP_Window_SetMenuState = ^tMUIP_Window_SetMenuState;
+
+       tMUIP_Window_Snapshot = record
+            MethodID : LongWord;
+            flags : LONG;
+         end;
+       pMUIP_Window_Snapshot = ^tMUIP_Window_Snapshot;
+
+       tMUIP_Window_ToBack = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Window_ToBack = ^tMUIP_Window_ToBack;
+
+       tMUIP_Window_ToFront = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Window_ToFront = ^tMUIP_Window_ToFront;
+
+    { Attributes  }
+    { V4  isg BOOL               }
+
+    const
+       MUIA_Window_Activate = $80428d2f;
+    { V4  .sg Object             }
+       MUIA_Window_ActiveObject = $80427925;
+    { V4  i.g LONG               }
+       MUIA_Window_AltHeight = $8042cce3;
+    { V4  i.g LONG               }
+       MUIA_Window_AltLeftEdge = $80422d65;
+    { V4  i.g LONG               }
+       MUIA_Window_AltTopEdge = $8042e99b;
+    { V4  i.g LONG               }
+       MUIA_Window_AltWidth = $804260f4;
+    { V5  i.. BOOL               }
+       MUIA_Window_AppWindow = $804280cf;
+    { V4  i.. BOOL               }
+       MUIA_Window_Backdrop = $8042c0bb;
+    { V4  i.. BOOL               }
+       MUIA_Window_Borderless = $80429b79;
+    { V4  i.. BOOL               }
+       MUIA_Window_CloseGadget = $8042a110;
+    { V4  ..g BOOL               }
+       MUIA_Window_CloseRequest = $8042e86e;
+    { V4  isg Object             }
+       MUIA_Window_DefaultObject = $804294d7;
+    { V4  i.. BOOL               }
+       MUIA_Window_DepthGadget = $80421923;
+    { V4  i.. BOOL               }
+       MUIA_Window_DragBar = $8042045d;
+    { V8  isg BOOL               }
+       MUIA_Window_FancyDrawing = $8042bd0e;
+    { V4  i.g LONG               }
+       MUIA_Window_Height = $80425846;
+    { V4  isg LongWord              }
+       MUIA_Window_ID = $804201bd;
+    { V4  ..g struct InputEvent    }
+       MUIA_Window_InputEvent = $804247d8;
+    { V4  isg BOOL               }
+       MUIA_Window_IsSubWindow = $8042b5aa;
+    { V4  i.g LONG               }
+       MUIA_Window_LeftEdge = $80426c65;
+    { MUI_OBSOLETE  }
+    { V8  isg LongWord              }
+
+    const
+       MUIA_Window_MenuAction = $80427521;
+    { V8  i.g Object             }
+       MUIA_Window_Menustrip = $8042855e;
+    { V10 ..g Object             }
+       MUIA_Window_MouseObject = $8042bf9b;
+    { V10 i.. BOOL               }
+       MUIA_Window_NeedsMouseObject = $8042372a;
+    { V4  is. BOOL               }
+       MUIA_Window_NoMenus = $80429df5;
+    { V4  .sg BOOL               }
+       MUIA_Window_Open = $80428aa0;
+    { V6  isg STRPTR             }
+       MUIA_Window_PublicScreen = $804278e4;
+    { V4  is. Object             }
+       MUIA_Window_RefWindow = $804201f4;
+    { V4  isg Object             }
+       MUIA_Window_RootObject = $8042cba5;
+    { V4  isg struct Screen      }
+       MUIA_Window_Screen = $8042df4f;
+    { V5  isg STRPTR             }
+       MUIA_Window_ScreenTitle = $804234b0;
+    { V4  i.. BOOL               }
+       MUIA_Window_SizeGadget = $8042e33d;
+    { V4  i.. BOOL               }
+       MUIA_Window_SizeRight = $80424780;
+    { V4  .sg BOOL               }
+       MUIA_Window_Sleep = $8042e7db;
+    { V4  isg STRPTR             }
+       MUIA_Window_Title = $8042ad3d;
+    { V4  i.g LONG               }
+       MUIA_Window_TopEdge = $80427c66;
+    { V13 isg BOOL               }
+       MUIA_Window_UseBottomBorderScroller = $80424e79;
+    { V13 isg BOOL               }
+       MUIA_Window_UseLeftBorderScroller = $8042433e;
+    { V13 isg BOOL               }
+       MUIA_Window_UseRightBorderScroller = $8042c05e;
+    { V4  i.g LONG               }
+       MUIA_Window_Width = $8042dcae;
+    { V4  ..g struct Window      }
+       MUIA_Window_Window = $80426a42;
+       MUIV_Window_ActiveObject_None = 0;
+       MUIV_Window_ActiveObject_Next = -(1);
+       MUIV_Window_ActiveObject_Prev = -(2);
+
+
+    const
+       MUIV_Window_AltHeight_Scaled = -(1000);
+       MUIV_Window_AltLeftEdge_Centered = -(1);
+       MUIV_Window_AltLeftEdge_Moused = -(2);
+       MUIV_Window_AltLeftEdge_NoChange = -(1000);
+       MUIV_Window_AltTopEdge_Centered = -(1);
+       MUIV_Window_AltTopEdge_Moused = -(2);
+
+
+    const
+       MUIV_Window_AltTopEdge_NoChange = -(1000);
+
+
+    const
+       MUIV_Window_AltWidth_Scaled = -(1000);
+
+
+
+    const
+       MUIV_Window_Height_Scaled = -(1000);
+       MUIV_Window_Height_Default = -(1001);
+       MUIV_Window_LeftEdge_Centered = -(1);
+       MUIV_Window_LeftEdge_Moused = -(2);
+
+
+    const
+       MUIV_Window_TopEdge_Centered = -(1);
+       MUIV_Window_TopEdge_Moused = -(2);
+
+
+    const
+       MUIV_Window_Width_Scaled = -(1000);
+       MUIV_Window_Width_Default = -(1001);
+    {                                                                           }
+    {  Aboutmui                                                                 }
+    {                                                                           }
+
+
+    const
+       MUIC_Aboutmui : PChar = 'Aboutmui.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V11 i.. Object             }
+
+    const
+       MUIA_Aboutmui_Application = $80422523;
+    {                                                                           }
+    {  Area                                                                     }
+    {                                                                           }
+
+
+    const
+       MUIC_Area : PChar = 'Area.mui';
+
+    { Methods  }
+    { Custom Class  }
+    { V4   }
+
+    const
+       MUIM_AskMinMax = $80423874;
+    { Custom Class  }
+    { V4   }
+       MUIM_Cleanup = $8042d985;
+    { V11  }
+       MUIM_ContextMenuBuild = $80429d2e;
+    { V11  }
+       MUIM_ContextMenuChoice = $80420f0e;
+    { V18  }
+       MUIM_CreateBubble = $80421c41;
+    { V11  }
+       MUIM_CreateShortHelp = $80428e93;
+    { V18  }
+       MUIM_DeleteBubble = $804211af;
+    { V11  }
+       MUIM_DeleteShortHelp = $8042d35a;
+    { V11  }
+       MUIM_DragBegin = $8042c03a;
+    { V11  }
+       MUIM_DragDrop = $8042c555;
+    { V11  }
+       MUIM_DragFinish = $804251f0;
+    { V11  }
+       MUIM_DragQuery = $80420261;
+    { V11  }
+       MUIM_DragReport = $8042edad;
+    { Custom Class  }
+    { V4   }
+       MUIM_Draw = $80426f3f;
+    { V11  }
+       MUIM_DrawBackground = $804238ca;
+    { Custom Class  }
+    { V16  }
+       MUIM_HandleEvent = $80426d66;
+    { Custom Class  }
+    { V4   }
+       MUIM_HandleInput = $80422a1a;
+    { Custom Class  }
+    { V4   }
+       MUIM_Hide = $8042f20f;
+    { Custom Class  }
+    { V4   }
+       MUIM_Setup = $80428354;
+    { Custom Class  }
+    { V4   }
+       MUIM_Show = $8042cc84;
+
+    type
+
+     { MUI_MinMax structure holds information about minimum, maximum
+       and default dimensions of an object.  }
+       tMUI_MinMax = record
+            MinWidth : WORD;
+            MinHeight : WORD;
+            MaxWidth : WORD;
+            MaxHeight : WORD;
+            DefWidth : WORD;
+            DefHeight : WORD;
+         end;
+       pMUI_MinMax = ^tMUI_MinMax;
+
+       tMUIP_AskMinMax = record
+            MethodID : LongWord;
+            MinMaxInfo : PMUI_MinMax;
+         end;
+       pMUIP_AskMinMax = ^tMUIP_AskMinMax;
+
+    { Custom Class  }
+       tMUIP_Cleanup = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Cleanup  = ^tMUIP_Cleanup;
+
+    { Custom Class  }
+       tMUIP_ContextMenuBuild = record
+            MethodID : LongWord;
+            mx : LONG;
+            my : LONG;
+         end;
+       pMUIP_ContextMenuBuild = ^tMUIP_ContextMenuBuild;
+
+       tMUIP_ContextMenuChoice = record
+            MethodID : LongWord;
+            item : PObject_;
+         end;
+       pMUIP_ContextMenuChoice = ^tMUIP_ContextMenuChoice;
+
+       tMUIP_CreateBubble = record
+            MethodID : LongWord;
+            x : LONG;
+            y : LONG;
+            txt : Pchar;
+            flags : LongWord;
+         end;
+       pMUIP_CreateBubble = ^tMUIP_CreateBubble;
+
+       tMUIP_CreateShortHelp = record
+            MethodID : LongWord;
+            mx : LONG;
+            my : LONG;
+         end;
+       pMUIP_CreateShortHelp = ^tMUIP_CreateShortHelp;
+
+       tMUIP_DeleteBubble = record
+            MethodID : LongWord;
+            bubble : APTR;
+         end;
+       pMUIP_DeleteBubble = ^tMUIP_DeleteBubble;
+
+       tMUIP_DeleteShortHelp = record
+            MethodID : LongWord;
+            help : STRPTR;
+         end;
+       pMUIP_DeleteShortHelp = ^tMUIP_DeleteShortHelp;
+
+       tMUIP_DragBegin = record
+            MethodID : LongWord;
+            obj : PObject_;
+         end;
+       pMUIP_DragBegin = ^tMUIP_DragBegin;
+
+       tMUIP_DragDrop = record
+            MethodID : LongWord;
+            obj : PObject_;
+            x : LONG;
+            y : LONG;
+         end;
+       pMUIP_DragDrop = ^tMUIP_DragDrop;
+
+       tMUIP_DragFinish = record
+            MethodID : LongWord;
+            obj : PObject_;
+         end;
+       pMUIP_DragFinish = ^tMUIP_DragFinish;
+
+       tMUIP_DragQuery = record
+            MethodID : LongWord;
+            obj : PObject_;
+         end;
+       pMUIP_DragQuery = ^tMUIP_DragQuery;
+
+       tMUIP_DragReport = record
+            MethodID : LongWord;
+            obj : PObject_;
+            x : LONG;
+            y : LONG;
+            update : LONG;
+         end;
+       pMUIP_DragReport = ^tMUIP_DragReport;
+
+       tMUIP_Draw = record
+            MethodID : LongWord;
+            flags : LongWord;
+         end;
+       pMUIP_Draw = ^tMUIP_Draw;
+
+    { Custom Class  }
+       tMUIP_DrawBackground = record
+            MethodID : LongWord;
+            left : LONG;
+            top : LONG;
+            width : LONG;
+            height : LONG;
+            xoffset : LONG;
+            yoffset : LONG;
+            flags : LONG;
+         end;
+       pMUIP_DrawBackground = ^tMUIP_DrawBackground;
+
+       tMUIP_HandleEvent = record
+            MethodID : LongWord;
+            imsg : PIntuiMessage;
+            muikey : LONG;
+         end;
+       pMUIP_HandleEvent = ^tMUIP_HandleEvent;
+
+    { Custom Class  }
+       tMUIP_HandleInput = record
+            MethodID : LongWord;
+            imsg : PIntuiMessage;
+            muikey : LONG;
+         end;
+       pMUIP_HandleInput = ^tMUIP_HandleInput;
+
+    { Custom Class  }
+       tMUIP_Hide = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Hide = ^tMUIP_Hide;
+
+    { Custom Class  }
+       tMUIP_Setup = record
+            MethodID : LongWord;
+            RenderInfo : PMUI_RenderInfo;
+         end;
+       pMUIP_Setup = ^tMUIP_Setup;
+
+    { Custom Class  }
+       tMUIP_Show = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Show = ^tMUIP_Show;
+
+    { Custom Class  }
+    { Attributes  }
+    { V4  is. LONG               }
+
+    const
+       MUIA_Background = $8042545b;
+    { V4  ..g LONG               }
+       MUIA_BottomEdge = $8042e552;
+    { V11 isg Object             }
+       MUIA_ContextMenu = $8042b704;
+    { V11 ..g Object             }
+       MUIA_ContextMenuTrigger = $8042a2c1;
+    { V4  isg char               }
+       MUIA_ControlChar = $8042120b;
+    { V11 isg LONG               }
+       MUIA_CycleChain = $80421ce7;
+    { V4  isg BOOL               }
+       MUIA_Disabled = $80423661;
+    { V11 isg BOOL               }
+       MUIA_Draggable = $80420b6e;
+    { V11 isg BOOL               }
+       MUIA_Dropable = $8042fbce;
+
+    { V4  is. BOOL               }
+
+    const
+       MUIA_FillArea = $804294a3;
+    { V4  i.. LONG               }
+       MUIA_FixHeight = $8042a92b;
+    { V4  i.. STRPTR             }
+       MUIA_FixHeightTxt = $804276f2;
+    { V4  i.. LONG               }
+       MUIA_FixWidth = $8042a3f1;
+    { V4  i.. STRPTR             }
+       MUIA_FixWidthTxt = $8042d044;
+    { V4  i.g struct TextFont    }
+       MUIA_Font = $8042be50;
+    { V4  i.. LONG               }
+       MUIA_Frame = $8042ac64;
+    { V4  i.. BOOL               }
+       MUIA_FramePhantomHoriz = $8042ed76;
+    { V4  i.. STRPTR             }
+       MUIA_FrameTitle = $8042d1c7;
+    { V4  ..g LONG               }
+       MUIA_Height = $80423237;
+    { V11 isg LONG               }
+       MUIA_HorizDisappear = $80429615;
+    { V4  isg WORD               }
+       MUIA_HorizWeight = $80426db9;
+    { V4  i.g LONG               }
+       MUIA_InnerBottom = $8042f2c0;
+    { V4  i.g LONG               }
+       MUIA_InnerLeft = $804228f8;
+    { V4  i.g LONG               }
+       MUIA_InnerRight = $804297ff;
+    { V4  i.g LONG               }
+       MUIA_InnerTop = $80421eb6;
+    { V4  i.. LONG               }
+       MUIA_InputMode = $8042fb04;
+    { V4  ..g LONG               }
+       MUIA_LeftEdge = $8042bec6;
+    { V11 i.. LONG               }
+       MUIA_MaxHeight = $804293e4;
+    { V11 i.. LONG               }
+       MUIA_MaxWidth = $8042f112;
+    { V4  ..g BOOL               }
+       MUIA_Pressed = $80423535;
+    { V4  ..g LONG               }
+       MUIA_RightEdge = $8042ba82;
+    { V4  isg BOOL               }
+       MUIA_Selected = $8042654b;
+    { V11 isg STRPTR             }
+       MUIA_ShortHelp = $80428fe3;
+    { V4  isg BOOL               }
+       MUIA_ShowMe = $80429ba8;
+    { V4  i.. BOOL               }
+       MUIA_ShowSelState = $8042caac;
+    { V4  ..g LONG               }
+       MUIA_Timer = $80426435;
+    { V4  ..g LONG               }
+       MUIA_TopEdge = $8042509b;
+    { V11 isg LONG               }
+       MUIA_VertDisappear = $8042d12f;
+    { V4  isg WORD               }
+       MUIA_VertWeight = $804298d0;
+    { V4  i.. WORD               }
+       MUIA_Weight = $80421d1f;
+    { V4  ..g LONG               }
+       MUIA_Width = $8042b59c;
+    { V4  ..g struct Window      }
+       MUIA_Window = $80421591;
+    { V4  ..g Object             }
+       MUIA_WindowObject = $8042669e;
+       MUIV_Font_Inherit = 0;
+       MUIV_Font_Normal = -(1);
+       MUIV_Font_List = -(2);
+       MUIV_Font_Tiny = -(3);
+       MUIV_Font_Fixed = -(4);
+       MUIV_Font_Title = -(5);
+       MUIV_Font_Big = -(6);
+       MUIV_Font_Button = -(7);
+       MUIV_Frame_None = 0;
+       MUIV_Frame_Button = 1;
+       MUIV_Frame_ImageButton = 2;
+       MUIV_Frame_Text = 3;
+       MUIV_Frame_String = 4;
+       MUIV_Frame_ReadList = 5;
+       MUIV_Frame_InputList = 6;
+       MUIV_Frame_Prop = 7;
+       MUIV_Frame_Gauge = 8;
+       MUIV_Frame_Group = 9;
+       MUIV_Frame_PopUp = 10;
+       MUIV_Frame_Virtual = 11;
+       MUIV_Frame_Slider = 12;
+       MUIV_Frame_Count = 13;
+       MUIV_InputMode_None = 0;
+       MUIV_InputMode_RelVerify = 1;
+       MUIV_InputMode_Immediate = 2;
+       MUIV_InputMode_Toggle = 3;
+    {                                                                           }
+    {  Rectangle                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Rectangle : PChar = 'Rectangle.mui';
+
+    { Attributes  }
+    { V11 i.g STRPTR             }
+
+    const
+       MUIA_Rectangle_BarTitle = $80426689;
+    { V7  i.g BOOL               }
+       MUIA_Rectangle_HBar = $8042c943;
+    { V7  i.g BOOL               }
+       MUIA_Rectangle_VBar = $80422204;
+    {                                                                           }
+    {  Balance                                                                  }
+    {                                                                           }
+
+
+    const
+       MUIC_Balance : PChar = 'Balance.mui';
+
+    {                                                                           }
+    {  Image                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Image : PChar = 'Image.mui';
+
+    { Attributes  }
+    { V4  i.. BOOL               }
+
+    const
+       MUIA_Image_FontMatch = $8042815d;
+    { V4  i.. BOOL               }
+       MUIA_Image_FontMatchHeight = $80429f26;
+    { V4  i.. BOOL               }
+       MUIA_Image_FontMatchWidth = $804239bf;
+    { V4  i.. BOOL               }
+       MUIA_Image_FreeHoriz = $8042da84;
+    { V4  i.. BOOL               }
+       MUIA_Image_FreeVert = $8042ea28;
+    { V4  i.. struct Image       }
+       MUIA_Image_OldImage = $80424f3d;
+    { V4  i.. char               }
+       MUIA_Image_Spec = $804233d5;
+    { V4  is. LONG               }
+       MUIA_Image_State = $8042a3ad;
+    {                                                                           }
+    {  Bitmap                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Bitmap : PChar = 'Bitmap.mui';
+
+    { Attributes  }
+    { V8  isg struct BitMap      }
+
+    const
+       MUIA_Bitmap_Bitmap = $804279bd;
+    { V8  isg LONG               }
+       MUIA_Bitmap_Height = $80421560;
+    { V8  isg UBYTE              }
+       MUIA_Bitmap_MappingTable = $8042e23d;
+    { V11 isg LONG               }
+       MUIA_Bitmap_Precision = $80420c74;
+    { V11 ..g struct BitMap      }
+       MUIA_Bitmap_RemappedBitmap = $80423a47;
+    { V8  isg LongWord              }
+       MUIA_Bitmap_SourceColors = $80425360;
+    { V8  isg LONG               }
+       MUIA_Bitmap_Transparent = $80422805;
+    { V11 i.. BOOL               }
+       MUIA_Bitmap_UseFriend = $804239d8;
+    { V8  isg LONG               }
+       MUIA_Bitmap_Width = $8042eb3a;
+    {                                                                           }
+    {  Bodychunk                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Bodychunk : PChar = 'Bodychunk.mui';
+
+    { Attributes  }
+    { V8  isg UBYTE              }
+
+    const
+       MUIA_Bodychunk_Body = $8042ca67;
+    { V8  isg UBYTE              }
+       MUIA_Bodychunk_Compression = $8042de5f;
+    { V8  isg LONG               }
+       MUIA_Bodychunk_Depth = $8042c392;
+    { V8  isg UBYTE              }
+       MUIA_Bodychunk_Masking = $80423b0e;
+    {                                                                           }
+    {  Text                                                                     }
+    {                                                                           }
+
+    const
+       MUIC_Text : PChar = 'Text.mui';
+
+    { Attributes  }
+    { V4  isg STRPTR             }
+
+    const
+       MUIA_Text_Contents = $8042f8dc;
+    { V4  i.. char               }
+       MUIA_Text_HiChar = $804218ff;
+    { V4  isg STRPTR             }
+       MUIA_Text_PreParse = $8042566d;
+    { V4  i.. BOOL               }
+       MUIA_Text_SetMax = $80424d0a;
+    { V4  i.. BOOL               }
+       MUIA_Text_SetMin = $80424e10;
+    { V11 i.. BOOL               }
+       MUIA_Text_SetVMax = $80420d8b;
+    {                                                                           }
+    {  Gadget                                                                   }
+    {                                                                           }
+
+    const
+       MUIC_Gadget : PChar = 'Gadget.mui';
+
+    { Attributes  }
+    { V11 ..g struct Gadget      }
+
+    const
+       MUIA_Gadget_Gadget = $8042ec1a;
+    {                                                                           }
+    {  String                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_String : PChar = 'String.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V4  isg STRPTR             }
+
+    const
+       MUIA_String_Accept = $8042e3e1;
+    { V4  ..g STRPTR             }
+       MUIA_String_Acknowledge = $8042026c;
+    { V11 isg BOOL               }
+       MUIA_String_AdvanceOnCR = $804226de;
+    { V4  isg Object             }
+       MUIA_String_AttachedList = $80420fd2;
+    { V4  .sg LONG               }
+       MUIA_String_BufferPos = $80428b6c;
+    { V4  isg STRPTR             }
+       MUIA_String_Contents = $80428ffd;
+    { V4  .sg LONG               }
+       MUIA_String_DisplayPos = $8042ccbf;
+    { V7  isg struct Hook        }
+       MUIA_String_EditHook = $80424c33;
+    { V4  i.g LONG               }
+       MUIA_String_Format = $80427484;
+    { V4  isg LongWord              }
+       MUIA_String_Integer = $80426e8a;
+    { V11 isg BOOL               }
+       MUIA_String_LonelyEditHook = $80421569;
+    { V4  i.g LONG               }
+       MUIA_String_MaxLen = $80424984;
+    { V4  isg STRPTR             }
+       MUIA_String_Reject = $8042179c;
+    { V4  i.g BOOL               }
+       MUIA_String_Secret = $80428769;
+       MUIV_String_Format_Left = 0;
+       MUIV_String_Format_Center = 1;
+       MUIV_String_Format_Right = 2;
+    {                                                                           }
+    {  Boopsi                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Boopsi : PChar = 'Boopsi.mui';
+
+    { Attributes  }
+    { V4  isg struct IClass      }
+
+    const
+       MUIA_Boopsi_Class = $80426999;
+    { V4  isg char               }
+       MUIA_Boopsi_ClassID = $8042bfa3;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_MaxHeight = $8042757f;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_MaxWidth = $8042bcb1;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_MinHeight = $80422c93;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_MinWidth = $80428fb2;
+    { V4  ..g Object             }
+       MUIA_Boopsi_Object = $80420178;
+    { V4  i.. LongWord              }
+       MUIA_Boopsi_Remember = $8042f4bd;
+    { V9  i.. BOOL               }
+       MUIA_Boopsi_Smart = $8042b8d7;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_TagDrawInfo = $8042bae7;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_TagScreen = $8042bc71;
+    { V4  isg LongWord              }
+       MUIA_Boopsi_TagWindow = $8042e11d;
+    {                                                                           }
+    {  Prop                                                                     }
+    {                                                                           }
+
+
+    const
+       MUIC_Prop : PChar = 'Prop.mui';
+
+    { Methods  }
+    { V16  }
+
+    const
+       MUIM_Prop_Decrease = $80420dd1;
+    { V16  }
+       MUIM_Prop_Increase = $8042cac0;
+
+    type
+       tMUIP_Prop_Decrease = record
+            MethodID : LongWord;
+            amount : LONG;
+         end;
+       pMUIP_Prop_Decrease = ^tMUIP_Prop_Decrease;
+
+       tMUIP_Prop_Increase = record
+            MethodID : LongWord;
+            amount : LONG;
+         end;
+       pMUIP_Prop_Increase = ^tMUIP_Prop_Increase;
+
+    { Attributes  }
+    { V4  isg LONG               }
+
+    const
+       MUIA_Prop_Entries = $8042fbdb;
+    { V4  isg LONG               }
+       MUIA_Prop_First = $8042d4b2;
+    { V4  i.g BOOL               }
+       MUIA_Prop_Horiz = $8042f4f3;
+    { V4  isg BOOL               }
+       MUIA_Prop_Slider = $80429c3a;
+    { V13 i.. LONG               }
+       MUIA_Prop_UseWinBorder = $8042deee;
+    { V4  isg LONG               }
+       MUIA_Prop_Visible = $8042fea6;
+       MUIV_Prop_UseWinBorder_None = 0;
+       MUIV_Prop_UseWinBorder_Left = 1;
+       MUIV_Prop_UseWinBorder_Right = 2;
+       MUIV_Prop_UseWinBorder_Bottom = 3;
+    {                                                                           }
+    {  Gauge                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Gauge : PChar = 'Gauge.mui';
+
+    { Attributes  }
+    { V4  isg LONG               }
+
+    const
+       MUIA_Gauge_Current = $8042f0dd;
+    { V4  isg BOOL               }
+       MUIA_Gauge_Divide = $8042d8df;
+    { V4  i.. BOOL               }
+       MUIA_Gauge_Horiz = $804232dd;
+    { V7  isg STRPTR             }
+       MUIA_Gauge_InfoText = $8042bf15;
+    { V4  isg LONG               }
+       MUIA_Gauge_Max = $8042bcdb;
+    {                                                                           }
+    {  Scale                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Scale : PChar = 'Scale.mui';
+
+    { Attributes  }
+    { V4  isg BOOL               }
+
+    const
+       MUIA_Scale_Horiz = $8042919a;
+    {                                                                           }
+    {  Colorfield                                                               }
+    {                                                                           }
+
+
+    const
+       MUIC_Colorfield : PChar = 'Colorfield.mui';
+
+    { Attributes  }
+    { V4  isg LongWord              }
+
+    const
+       MUIA_Colorfield_Blue = $8042d3b0;
+    { V4  isg LongWord              }
+       MUIA_Colorfield_Green = $80424466;
+    { V4  ..g LongWord              }
+       MUIA_Colorfield_Pen = $8042713a;
+    { V4  isg LongWord              }
+       MUIA_Colorfield_Red = $804279f6;
+    { V4  isg LongWord              }
+       MUIA_Colorfield_RGB = $8042677a;
+    {                                                                           }
+    {  List                                                                     }
+    {                                                                           }
+
+
+    const
+       MUIC_List : PChar = 'List.mui';
+
+    { Methods  }
+    { V4   }
+
+    const
+       MUIM_List_Clear = $8042ad89;
+    { V11  }
+       MUIM_List_CreateImage = $80429804;
+    { V11  }
+       MUIM_List_DeleteImage = $80420f58;
+    { V4   }
+       MUIM_List_Exchange = $8042468c;
+    { V4   }
+       MUIM_List_GetEntry = $804280ec;
+    { V4   }
+       MUIM_List_Insert = $80426c87;
+    { V7   }
+       MUIM_List_InsertSingle = $804254d5;
+    { V4   }
+       MUIM_List_Jump = $8042baab;
+    { V9   }
+       MUIM_List_Move = $804253c2;
+    { V6   }
+       MUIM_List_NextSelected = $80425f17;
+    { V4   }
+       MUIM_List_Redraw = $80427993;
+    { V4   }
+       MUIM_List_Remove = $8042647e;
+    { V4   }
+       MUIM_List_Select = $804252d8;
+    { V4   }
+       MUIM_List_Sort = $80422275;
+    { V11  }
+       MUIM_List_TestPos = $80425f48;
+
+    type
+       tMUIP_List_Clear = record
+            MethodID : LongWord;
+         end;
+       pMUIP_List_Clear = ^tMUIP_List_Clear;
+
+       tMUIP_List_CreateImage = record
+            MethodID : LongWord;
+            obj : PObject_;
+            flags : LongWord;
+         end;
+       pMUIP_List_CreateImage = ^tMUIP_List_CreateImage;
+
+       tMUIP_List_DeleteImage = record
+            MethodID : LongWord;
+            listimg : APTR;
+         end;
+       pMUIP_List_DeleteImage = ^tMUIP_List_DeleteImage;
+
+       tMUIP_List_Exchange = record
+            MethodID : LongWord;
+            pos1 : LONG;
+            pos2 : LONG;
+         end;
+       pMUIP_List_Exchange = ^tMUIP_List_Exchange;
+
+       tMUIP_List_GetEntry = record
+            MethodID : LongWord;
+            pos : LONG;
+            entry : PAPTR;
+         end;
+       pMUIP_List_GetEntry = ^tMUIP_List_GetEntry;
+
+       tMUIP_List_Insert = record
+            MethodID : LongWord;
+            entries : PAPTR;
+            count : LONG;
+            pos : LONG;
+         end;
+       pMUIP_List_Insert = ^tMUIP_List_Insert;
+
+       tMUIP_List_InsertSingle = record
+            MethodID : LongWord;
+            entry : APTR;
+            pos : LONG;
+         end;
+       pMUIP_List_InsertSingle = ^tMUIP_List_InsertSingle;
+
+       tMUIP_List_Jump = record
+            MethodID : LongWord;
+            pos : LONG;
+         end;
+       pMUIP_List_Jump = ^tMUIP_List_Jump;
+
+       tMUIP_List_Move = record
+            MethodID : LongWord;
+            from : LONG;
+            too : LONG;
+         end;
+       pMUIP_List_Move = ^tMUIP_List_Move;
+
+       tMUIP_List_NextSelected = record
+            MethodID : LongWord;
+            pos : PLONG;
+         end;
+       pMUIP_List_NextSelected = ^tMUIP_List_NextSelected;
+
+       tMUIP_List_Redraw = record
+            MethodID : LongWord;
+            pos : LONG;
+         end;
+       pMUIP_List_Redraw = ^tMUIP_List_Redraw;
+
+       tMUIP_List_Remove = record
+            MethodID : LongWord;
+            pos : LONG;
+         end;
+       pMUIP_List_Remove = ^tMUIP_List_Remove;
+
+       tMUIP_List_Select = record
+            MethodID : LongWord;
+            pos : LONG;
+            seltype : LONG;
+            state : PLONG;
+         end;
+       pMUIP_List_Select = ^tMUIP_List_Select;
+
+       tMUIP_List_Sort = record
+            MethodID : LongWord;
+         end;
+       pMUIP_List_Sort = ^tMUIP_List_Sort;
+
+       tMUIP_List_TestPos = record
+            MethodID : LongWord;
+            x : LONG;
+            y : LONG;
+            res : PMUI_List_TestPos_Result;
+         end;
+       pMUIP_List_TestPos = ^tMUIP_List_TestPos;
+
+    { Attributes  }
+    { V4  isg LONG               }
+
+    const
+       MUIA_List_Active = $8042391c;
+    { V4  i.. BOOL               }
+       MUIA_List_AdjustHeight = $8042850d;
+    { V4  i.. BOOL               }
+       MUIA_List_AdjustWidth = $8042354a;
+    { V11 isg BOOL               }
+       MUIA_List_AutoVisible = $8042a445;
+    { V4  is. struct Hook        }
+       MUIA_List_CompareHook = $80425c14;
+    { V4  is. struct Hook        }
+       MUIA_List_ConstructHook = $8042894f;
+    { V4  is. struct Hook        }
+       MUIA_List_DestructHook = $804297ce;
+    { V4  is. struct Hook        }
+       MUIA_List_DisplayHook = $8042b4d5;
+    { V11 isg BOOL               }
+       MUIA_List_DragSortable = $80426099;
+    { V11 ..g LONG               }
+       MUIA_List_DropMark = $8042aba6;
+    { V4  ..g LONG               }
+       MUIA_List_Entries = $80421654;
+    { V4  ..g LONG               }
+       MUIA_List_First = $804238d4;
+    { V4  isg STRPTR             }
+       MUIA_List_Format = $80423c0a;
+    { V9  ..g LONG               }
+       MUIA_List_InsertPosition = $8042d0cd;
+    { V4  i.. LONG               }
+       MUIA_List_MinLineHeight = $8042d1c3;
+    { V4  is. struct Hook        }
+       MUIA_List_MultiTestHook = $8042c2c6;
+    { V13 i.. APTR               }
+       MUIA_List_Pool = $80423431;
+    { V13 i.. LongWord              }
+       MUIA_List_PoolPuddleSize = $8042a4eb;
+    { V13 i.. LongWord              }
+       MUIA_List_PoolThreshSize = $8042c48c;
+    { V4  .s. BOOL               }
+       MUIA_List_Quiet = $8042d8c7;
+    { V11 isg BOOL               }
+       MUIA_List_ShowDropMarks = $8042c6f3;
+    { V4  i.. APTR               }
+       MUIA_List_SourceArray = $8042c0a0;
+    { V6  isg char               }
+       MUIA_List_Title = $80423e66;
+    { V4  ..g LONG               }
+       MUIA_List_Visible = $8042191f;
+       MUIV_List_Active_Off = -(1);
+       MUIV_List_Active_Top = -(2);
+       MUIV_List_Active_Bottom = -(3);
+       MUIV_List_Active_Up = -(4);
+       MUIV_List_Active_Down = -(5);
+       MUIV_List_Active_PageUp = -(6);
+       MUIV_List_Active_PageDown = -(7);
+       MUIV_List_ConstructHook_String = -(1);
+       MUIV_List_CopyHook_String = -(1);
+       MUIV_List_CursorType_None = 0;
+       MUIV_List_CursorType_Bar = 1;
+       MUIV_List_CursorType_Rect = 2;
+       MUIV_List_DestructHook_String = -(1);
+    {                                                                           }
+    {  Floattext                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Floattext : PChar = 'Floattext.mui';
+
+    { Attributes  }
+    { V4  isg BOOL               }
+
+    const
+       MUIA_Floattext_Justify = $8042dc03;
+    { V4  is. STRPTR             }
+       MUIA_Floattext_SkiPChars = $80425c7d;
+    { V4  is. LONG               }
+       MUIA_Floattext_TabSize = $80427d17;
+    { V4  isg STRPTR             }
+       MUIA_Floattext_Text = $8042d16a;
+    {                                                                           }
+    {  Volumelist                                                               }
+    {                                                                           }
+
+
+    const
+       MUIC_Volumelist : PChar = 'Volumelist.mui';
+
+    {                                                                           }
+    {  Scrmodelist                                                              }
+    {                                                                           }
+
+    const
+       MUIC_Scrmodelist : PChar = 'Scrmodelist.mui';
+
+    { Attributes  }
+    {                                                                           }
+    {  Dirlist                                                                  }
+    {                                                                           }
+
+
+    const
+       MUIC_Dirlist : PChar = 'Dirlist.mui';
+
+    { Methods  }
+    { V4   }
+
+    const
+       MUIM_Dirlist_ReRead = $80422d71;
+
+    type
+       MUIP_Dirlist_ReRead = record
+            MethodID : LongWord;
+         end;
+
+    { Attributes  }
+    { V4  is. STRPTR             }
+
+    const
+       MUIA_Dirlist_AcceptPattern = $8042760a;
+    { V4  isg STRPTR             }
+       MUIA_Dirlist_Directory = $8042ea41;
+    { V4  is. BOOL               }
+       MUIA_Dirlist_DrawersOnly = $8042b379;
+    { V4  is. BOOL               }
+       MUIA_Dirlist_FilesOnly = $8042896a;
+    { V4  is. BOOL               }
+       MUIA_Dirlist_FilterDrawers = $80424ad2;
+    { V4  is. struct Hook        }
+       MUIA_Dirlist_FilterHook = $8042ae19;
+    { V6  is. BOOL               }
+       MUIA_Dirlist_MultiSelDirs = $80428653;
+    { V4  ..g LONG               }
+       MUIA_Dirlist_NumBytes = $80429e26;
+    { V4  ..g LONG               }
+       MUIA_Dirlist_NumDrawers = $80429cb8;
+    { V4  ..g LONG               }
+       MUIA_Dirlist_NumFiles = $8042a6f0;
+    { V4  ..g STRPTR             }
+       MUIA_Dirlist_Path = $80426176;
+    { V4  is. BOOL               }
+       MUIA_Dirlist_RejectIcons = $80424808;
+    { V4  is. STRPTR             }
+       MUIA_Dirlist_RejectPattern = $804259c7;
+    { V4  is. LONG               }
+       MUIA_Dirlist_SortDirs = $8042bbb9;
+    { V4  is. BOOL               }
+       MUIA_Dirlist_SortHighLow = $80421896;
+    { V4  is. LONG               }
+       MUIA_Dirlist_SortType = $804228bc;
+    { V4  ..g LONG               }
+       MUIA_Dirlist_Status = $804240de;
+       MUIV_Dirlist_SortDirs_First = 0;
+       MUIV_Dirlist_SortDirs_Last = 1;
+       MUIV_Dirlist_SortDirs_Mix = 2;
+       MUIV_Dirlist_SortType_Name = 0;
+       MUIV_Dirlist_SortType_Date = 1;
+       MUIV_Dirlist_SortType_Size = 2;
+       MUIV_Dirlist_Status_Invalid = 0;
+       MUIV_Dirlist_Status_Reading = 1;
+       MUIV_Dirlist_Status_Valid = 2;
+    {                                                                           }
+    {  Numeric                                                                  }
+    {                                                                           }
+
+    const
+       MUIC_Numeric : PChar = 'Numeric.mui';
+
+    { Methods  }
+    { V11  }
+
+    const
+       MUIM_Numeric_Decrease = $804243a7;
+    { V11  }
+       MUIM_Numeric_Increase = $80426ecd;
+    { V11  }
+       MUIM_Numeric_ScaleToValue = $8042032c;
+    { V11  }
+       MUIM_Numeric_SetDefault = $8042ab0a;
+    { V11  }
+       MUIM_Numeric_Stringify = $80424891;
+    { V11  }
+       MUIM_Numeric_ValueToScale = $80423e4f;
+
+    type
+       tMUIP_Numeric_Decrease = record
+            MethodID : LongWord;
+            amount : LONG;
+         end;
+       pMUIP_Numeric_Decrease = ^tMUIP_Numeric_Decrease;
+
+       tMUIP_Numeric_Increase = record
+            MethodID : LongWord;
+            amount : LONG;
+         end;
+       pMUIP_Numeric_Increase = ^tMUIP_Numeric_Increase;
+
+       tMUIP_Numeric_ScaleToValue = record
+            MethodID : LongWord;
+            scalemin : LONG;
+            scalemax : LONG;
+            scale : LONG;
+         end;
+       pMUIP_Numeric_ScaleToValue = ^tMUIP_Numeric_ScaleToValue;
+
+       tMUIP_Numeric_SetDefault = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Numeric_SetDefault = ^tMUIP_Numeric_SetDefault;
+
+       tMUIP_Numeric_Stringify = record
+            MethodID : LongWord;
+            value : LONG;
+         end;
+       pMUIP_Numeric_Stringify = ^tMUIP_Numeric_Stringify;
+
+       tMUIP_Numeric_ValueToScale = record
+            MethodID : LongWord;
+            scalemin : LONG;
+            scalemax : LONG;
+         end;
+       pMUIP_Numeric_ValueToScale = ^tMUIP_Numeric_ValueToScale;
+
+    { Attributes  }
+    { V11 isg BOOL               }
+
+    const
+       MUIA_Numeric_CheckAllSizes = $80421594;
+    { V11 isg LONG               }
+       MUIA_Numeric_Default = $804263e8;
+    { V11 isg STRPTR             }
+       MUIA_Numeric_Format = $804263e9;
+    { V11 isg LONG               }
+       MUIA_Numeric_Max = $8042d78a;
+    { V11 isg LONG               }
+       MUIA_Numeric_Min = $8042e404;
+    { V11 isg BOOL               }
+       MUIA_Numeric_Reverse = $8042f2a0;
+    { V11 isg BOOL               }
+       MUIA_Numeric_RevLeftRight = $804294a7;
+    { V11 isg BOOL               }
+       MUIA_Numeric_RevUpDown = $804252dd;
+    { V11 isg LONG               }
+       MUIA_Numeric_Value = $8042ae3a;
+    {                                                                           }
+    {  Knob                                                                     }
+    {                                                                           }
+
+
+    const
+       MUIC_Knob : PChar = 'Knob.mui';
+
+    {                                                                           }
+    {  Levelmeter                                                               }
+    {                                                                           }
+
+
+    const
+       MUIC_Levelmeter : PChar = 'Levelmeter.mui';
+
+    { Attributes  }
+    { V11 isg STRPTR             }
+
+    const
+       MUIA_Levelmeter_Label = $80420dd5;
+    {                                                                           }
+    {  Numericbutton                                                            }
+    {                                                                           }
+
+
+    const
+       MUIC_Numericbutton : PChar = 'Numericbutton.mui';
+
+    {                                                                           }
+    {  Slider                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Slider : PChar = 'Slider.mui';
+
+    { Attributes  }
+    { V11 isg BOOL               }
+
+    const
+       MUIA_Slider_Horiz = $8042fad1;
+
+    { V6  i.. BOOL               }
+
+    const
+       MUIA_Slider_Quiet = $80420b26;
+
+    {                                                                           }
+    {  Framedisplay                                                             }
+    {                                                                           }
+
+
+    const
+       MUIC_Framedisplay : PChar = 'Framedisplay.mui';
+
+    { Attributes  }
+    {                                                                           }
+    {  Popframe                                                                 }
+    {                                                                           }
+
+
+    const
+       MUIC_Popframe : PChar = 'Popframe.mui';
+
+    {                                                                           }
+    {  Imagedisplay                                                             }
+    {                                                                           }
+
+    const
+       MUIC_Imagedisplay : PChar = 'Imagedisplay.mui';
+
+    { Attributes  }
+    {                                                                           }
+    {  Popimage                                                                 }
+    {                                                                           }
+
+
+    const
+       MUIC_Popimage : PChar = 'Popimage.mui';
+
+    {                                                                           }
+    {  Pendisplay                                                               }
+    {                                                                           }
+
+
+    const
+       MUIC_Pendisplay : PChar = 'Pendisplay.mui';
+
+    { Methods  }
+    { V13  }
+
+    const
+       MUIM_Pendisplay_SetColormap = $80426c80;
+    { V13  }
+       MUIM_Pendisplay_SetMUIPen = $8042039d;
+    { V13  }
+       MUIM_Pendisplay_SetRGB = $8042c131;
+
+    type
+       MUIP_Pendisplay_SetColormap = record
+            MethodID : LongWord;
+            colormap : LONG;
+         end;
+
+       MUIP_Pendisplay_SetMUIPen = record
+            MethodID : LongWord;
+            muipen : LONG;
+         end;
+
+       MUIP_Pendisplay_SetRGB = record
+            MethodID : LongWord;
+            red : LongWord;
+            green : LongWord;
+            blue : LongWord;
+         end;
+
+    { Attributes  }
+    { V13 ..g Object             }
+
+    const
+       MUIA_Pendisplay_Pen = $8042a748;
+    { V13 isg Object             }
+       MUIA_Pendisplay_Reference = $8042dc24;
+    { V11 isg struct MUI_RGBcolor    }
+       MUIA_Pendisplay_RGBcolor = $8042a1a9;
+    { V11 isg struct MUI_PenSpec     }
+       MUIA_Pendisplay_Spec = $8042a204;
+    {                                                                           }
+    {  Poppen                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Poppen : PChar = 'Poppen.mui';
+
+    {                                                                           }
+    {  Group                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Group : PChar = 'Group.mui';
+
+    { Methods  }
+    { V11  }
+
+    const
+       MUIM_Group_ExitChange = $8042d1cc;
+    { V11  }
+       MUIM_Group_InitChange = $80420887;
+    { V4   }
+       MUIM_Group_Sort = $80427417;
+
+    type
+       tMUIP_Group_ExitChange = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Group_ExitChange = ^tMUIP_Group_ExitChange;
+
+       tMUIP_Group_InitChange = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Group_InitChange = ^tMUIP_Group_InitChange;
+
+       tMUIP_Group_Sort = record
+            MethodID : LongWord;
+            obj : array[0..0] of PObject_;
+         end;
+       pMUIP_Group_Sort = ^tMUIP_Group_Sort;
+
+    { Attributes  }
+    { V5  isg LONG               }
+
+    const
+       MUIA_Group_ActivePage = $80424199;
+    { V4  i.. Object             }
+       MUIA_Group_Child = $804226e6;
+    { V4  ..g struct List        }
+       MUIA_Group_ChildList = $80424748;
+    { V4  is. LONG               }
+       MUIA_Group_Columns = $8042f416;
+    { V4  i.. BOOL               }
+       MUIA_Group_Horiz = $8042536b;
+    { V4  isg LONG               }
+       MUIA_Group_HorizSpacing = $8042c651;
+    { V11 i.. struct Hook        }
+       MUIA_Group_LayoutHook = $8042c3b2;
+    { V5  i.. BOOL               }
+       MUIA_Group_PageMode = $80421a5f;
+    { V4  is. LONG               }
+       MUIA_Group_Rows = $8042b68f;
+    { V4  i.. BOOL               }
+       MUIA_Group_SameHeight = $8042037e;
+    { V4  i.. BOOL               }
+       MUIA_Group_SameSize = $80420860;
+    { V4  i.. BOOL               }
+       MUIA_Group_SameWidth = $8042b3ec;
+    { V4  is. LONG               }
+       MUIA_Group_Spacing = $8042866d;
+    { V4  isg LONG               }
+       MUIA_Group_VertSpacing = $8042e1bf;
+       MUIV_Group_ActivePage_First = 0;
+       MUIV_Group_ActivePage_Last = -(1);
+       MUIV_Group_ActivePage_Prev = -(2);
+       MUIV_Group_ActivePage_Next = -(3);
+       MUIV_Group_ActivePage_Advance = -(4);
+    {                                                                           }
+    {  Mccprefs                                                                 }
+    {                                                                           }
+
+
+    const
+       MUIC_Mccprefs : PChar = 'Mccprefs.mui';
+
+    {                                                                           }
+    {  Register                                                                 }
+    {                                                                           }
+
+    const
+       MUIC_Register : PChar = 'Register.mui';
+
+    { Attributes  }
+    { V7  i.g BOOL               }
+
+    const
+       MUIA_Register_Frame = $8042349b;
+    { V7  i.g STRPTR             }
+       MUIA_Register_Titles = $804297ec;
+    {                                                                           }
+    {  Penadjust                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Penadjust : PChar= 'Penadjust.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V11 i.. BOOL               }
+
+    const
+       MUIA_Penadjust_PSIMode = $80421cbb;
+    {                                                                           }
+    {  Settingsgroup                                                            }
+    {                                                                           }
+
+
+    const
+       MUIC_Settingsgroup : PChar = 'Settingsgroup.mui';
+
+    { Methods  }
+    { V11  }
+
+    const
+       MUIM_Settingsgroup_ConfigToGadgets = $80427043;
+    { V11  }
+       MUIM_Settingsgroup_GadgetsToConfig = $80425242;
+
+    type
+       tMUIP_Settingsgroup_ConfigToGadgets = record
+            MethodID : LongWord;
+            configdata : PObject_;
+         end;
+       pMUIP_Settingsgroup_ConfigToGadgets = ^tMUIP_Settingsgroup_ConfigToGadgets;
+
+       tMUIP_Settingsgroup_GadgetsToConfig = record
+            MethodID : LongWord;
+            configdata : PObject_;
+         end;
+       pMUIP_Settingsgroup_GadgetsToConfig = ^tMUIP_Settingsgroup_GadgetsToConfig;
+
+    { Attributes  }
+    {                                                                           }
+    {  Settings                                                                 }
+    {                                                                           }
+
+    const
+       MUIC_Settings : PChar = 'Settings.mui';
+
+    { Methods  }
+    { Attributes  }
+    {                                                                           }
+    {  Frameadjust                                                              }
+    {                                                                           }
+
+
+    const
+       MUIC_Frameadjust : PChar = 'Frameadjust.mui';
+
+    { Methods  }
+    { Attributes  }
+    {                                                                           }
+    {  Imageadjust                                                              }
+    {                                                                           }
+
+
+    const
+       MUIC_Imageadjust : PChar = 'Imageadjust.mui';
+
+    { Methods  }
+    { Attributes  }
+
+    const
+       MUIV_Imageadjust_Type_All = 0;
+       MUIV_Imageadjust_Type_Image = 1;
+       MUIV_Imageadjust_Type_Background = 2;
+       MUIV_Imageadjust_Type_Pen = 3;
+    {                                                                           }
+    {  Virtgroup                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Virtgroup : PChar = 'Virtgroup.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V6  ..g LONG               }
+
+    const
+       MUIA_Virtgroup_Height = $80423038;
+    { V11 i.. BOOL               }
+       MUIA_Virtgroup_Input = $80427f7e;
+    { V6  isg LONG               }
+       MUIA_Virtgroup_Left = $80429371;
+    { V6  isg LONG               }
+       MUIA_Virtgroup_Top = $80425200;
+    { V6  ..g LONG               }
+       MUIA_Virtgroup_Width = $80427c49;
+    {                                                                           }
+    {  Scrollgroup                                                              }
+    {                                                                           }
+
+
+    const
+       MUIC_Scrollgroup : PChar = 'Scrollgroup.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V4  i.g Object             }
+
+    const
+       MUIA_Scrollgroup_Contents = $80421261;
+    { V9  i.. BOOL               }
+       MUIA_Scrollgroup_FreeHoriz = $804292f3;
+    { V9  i.. BOOL               }
+       MUIA_Scrollgroup_FreeVert = $804224f2;
+    { V16 ..g Object             }
+       MUIA_Scrollgroup_HorizBar = $8042b63d;
+    { V13 i.. BOOL               }
+       MUIA_Scrollgroup_UseWinBorder = $804284c1;
+    { V16 ..g Object             }
+       MUIA_Scrollgroup_VertBar = $8042cdc0;
+    {                                                                           }
+    {  Scrollbar                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Scrollbar : PChar = 'Scrollbar.mui';
+
+    { Attributes  }
+    { V11 i.. LONG               }
+
+    const
+       MUIA_Scrollbar_Type = $8042fb6b;
+       MUIV_Scrollbar_Type_Default = 0;
+       MUIV_Scrollbar_Type_Bottom = 1;
+       MUIV_Scrollbar_Type_Top = 2;
+       MUIV_Scrollbar_Type_Sym = 3;
+    {                                                                           }
+    {  Listview                                                                 }
+    {                                                                           }
+
+
+    const
+       MUIC_Listview : PChar = 'Listview.mui';
+
+    { Attributes  }
+    { V7  ..g LONG               }
+
+    const
+       MUIA_Listview_ClickColumn = $8042d1b3;
+    { V7  isg LONG               }
+       MUIA_Listview_DefClickColumn = $8042b296;
+    { V4  i.g BOOL               }
+       MUIA_Listview_DoubleClick = $80424635;
+    { V11 isg LONG               }
+       MUIA_Listview_DragType = $80425cd3;
+    { V4  i.. BOOL               }
+       MUIA_Listview_Input = $8042682d;
+    { V4  i.g Object             }
+       MUIA_Listview_List = $8042bcce;
+    { V7  i.. LONG               }
+       MUIA_Listview_MultiSelect = $80427e08;
+    { V10 i.. BOOL               }
+       MUIA_Listview_ScrollerPos = $8042b1b4;
+    { V4  ..g BOOL               }
+       MUIA_Listview_SelectChange = $8042178f;
+       MUIV_Listview_DragType_None = 0;
+       MUIV_Listview_DragType_Immediate = 1;
+       MUIV_Listview_MultiSelect_None = 0;
+       MUIV_Listview_MultiSelect_Default = 1;
+       MUIV_Listview_MultiSelect_Shifted = 2;
+       MUIV_Listview_MultiSelect_Always = 3;
+       MUIV_Listview_ScrollerPos_Default = 0;
+       MUIV_Listview_ScrollerPos_Left = 1;
+       MUIV_Listview_ScrollerPos_Right = 2;
+       MUIV_Listview_ScrollerPos_None = 3;
+    {                                                                           }
+    {  Radio                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Radio : PChar = 'Radio.mui';
+
+    { Attributes  }
+    { V4  isg LONG               }
+
+    const
+       MUIA_Radio_Active = $80429b41;
+    { V4  i.. STRPTR             }
+       MUIA_Radio_Entries = $8042b6a1;
+    {                                                                           }
+    {  Cycle                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Cycle : PChar = 'Cycle.mui';
+
+    { Attributes  }
+    { V4  isg LONG               }
+
+    const
+       MUIA_Cycle_Active = $80421788;
+    { V4  i.. STRPTR             }
+       MUIA_Cycle_Entries = $80420629;
+       MUIV_Cycle_Active_Next = -(1);
+       MUIV_Cycle_Active_Prev = -(2);
+    {                                                                           }
+    {  Coloradjust                                                              }
+    {                                                                           }
+
+
+    const
+       MUIC_Coloradjust : PChar = 'Coloradjust.mui';
+
+    { Methods  }
+    { Attributes  }
+    { V4  isg LongWord              }
+
+    const
+       MUIA_Coloradjust_Blue = $8042b8a3;
+    { V4  isg LongWord              }
+       MUIA_Coloradjust_Green = $804285ab;
+    { V4  isg LongWord              }
+       MUIA_Coloradjust_ModeID = $8042ec59;
+    { V4  isg LongWord              }
+       MUIA_Coloradjust_Red = $80420eaa;
+    { V4  isg LongWord              }
+       MUIA_Coloradjust_RGB = $8042f899;
+    {                                                                           }
+    {  Palette                                                                  }
+    {                                                                           }
+
+
+    const
+       MUIC_Palette : PChar = 'Palette.mui';
+
+    { Attributes  }
+    { V6  i.g struct MUI_Palette_Entry    }
+
+    const
+       MUIA_Palette_Entries = $8042a3d8;
+    { V6  isg BOOL               }
+       MUIA_Palette_Groupable = $80423e67;
+    { V6  isg char               }
+       MUIA_Palette_Names = $8042c3a2;
+    {                                                                           }
+    {  Popstring                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Popstring : PChar = 'Popstring.mui';
+
+    { Methods  }
+    { V7   }
+
+    const
+       MUIM_Popstring_Close = $8042dc52;
+    { V7   }
+       MUIM_Popstring_Open = $804258ba;
+
+    type
+       tMUIP_Popstring_Close = record
+            MethodID : LongWord;
+            result : LONG;
+         end;
+       pMUIP_Popstring_Close = ^tMUIP_Popstring_Close;
+
+       tMUIP_Popstring_Open = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Popstring_Open = ^tMUIP_Popstring_Open;
+
+    { Attributes  }
+    { V7  i.g Object             }
+
+    const
+       MUIA_Popstring_Button = $8042d0b9;
+    { V7  isg struct Hook        }
+       MUIA_Popstring_CloseHook = $804256bf;
+    { V7  isg struct Hook        }
+       MUIA_Popstring_OpenHook = $80429d00;
+    { V7  i.g Object             }
+       MUIA_Popstring_String = $804239ea;
+    { V7  isg BOOL               }
+       MUIA_Popstring_Toggle = $80422b7a;
+    {                                                                           }
+    {  Popobject                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Popobject : PChar = 'Popobject.mui';
+
+    { Attributes  }
+    { V7  isg BOOL               }
+
+    const
+       MUIA_Popobject_Follow = $80424cb5;
+    { V7  isg BOOL               }
+       MUIA_Popobject_Light = $8042a5a3;
+    { V7  i.g Object             }
+       MUIA_Popobject_Object = $804293e3;
+    { V7  isg struct Hook        }
+       MUIA_Popobject_ObjStrHook = $8042db44;
+    { V7  isg struct Hook        }
+       MUIA_Popobject_StrObjHook = $8042fbe1;
+    { V7  isg BOOL               }
+       MUIA_Popobject_Volatile = $804252ec;
+    { V9  isg struct Hook        }
+       MUIA_Popobject_WindowHook = $8042f194;
+    {                                                                           }
+    {  Poplist                                                                  }
+    {                                                                           }
+
+
+    const
+       MUIC_Poplist : PChar = 'Poplist.mui';
+
+    { Attributes  }
+    { V8  i.. char               }
+
+    const
+       MUIA_Poplist_Array = $8042084c;
+    {                                                                           }
+    {  Popscreen                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Popscreen : PChar = 'Popscreen.mui';
+
+    { Attributes  }
+    {                                                                           }
+    {  Popasl                                                                   }
+    {                                                                           }
+
+    const
+       MUIC_Popasl : PChar = 'Popasl.mui';
+
+    { Attributes  }
+    { V7  ..g BOOL               }
+
+    const
+       MUIA_Popasl_Active = $80421b37;
+    { V7  isg struct Hook        }
+       MUIA_Popasl_StartHook = $8042b703;
+    { V7  isg struct Hook        }
+       MUIA_Popasl_StopHook = $8042d8d2;
+    { V7  i.g LongWord              }
+       MUIA_Popasl_Type = $8042df3d;
+    {                                                                           }
+    {  Semaphore                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Semaphore : PChar = 'Semaphore.mui';
+
+    { Methods  }
+    { V11  }
+
+    const
+       MUIM_Semaphore_Attempt = $80426ce2;
+    { V11  }
+       MUIM_Semaphore_AttemptShared = $80422551;
+    { V11  }
+       MUIM_Semaphore_Obtain = $804276f0;
+    { V11  }
+       MUIM_Semaphore_ObtainShared = $8042ea02;
+    { V11  }
+       MUIM_Semaphore_Release = $80421f2d;
+
+    type
+       tMUIP_Semaphore_Attempt = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Semaphore_Attempt = ^tMUIP_Semaphore_Attempt;
+
+       tMUIP_Semaphore_AttemptShared = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Semaphore_AttemptShared = ^tMUIP_Semaphore_AttemptShared;
+
+       tMUIP_Semaphore_Obtain = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Semaphore_Obtain = ^tMUIP_Semaphore_Obtain;
+
+       tMUIP_Semaphore_ObtainShared = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Semaphore_ObtainShared = ^tMUIP_Semaphore_ObtainShared;
+
+       tMUIP_Semaphore_Release = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Semaphore_Release = ^tMUIP_Semaphore_Release;
+
+    {                                                                           }
+    {  Applist                                                                  }
+    {                                                                           }
+
+    const
+       MUIC_Applist : PChar = 'Applist.mui';
+    { Methods  }
+    {                                                                           }
+    {  Cclist                                                                   }
+    {                                                                           }
+
+
+    const
+       MUIC_Cclist : PChar = 'Cclist.mui';
+
+    { Methods  }
+    {                                                                           }
+    {  Dataspace                                                                }
+    {                                                                           }
+
+
+    const
+       MUIC_Dataspace : PChar = 'Dataspace.mui';
+
+    { Methods  }
+    { V11  }
+
+    const
+       MUIM_Dataspace_Add = $80423366;
+    { V11  }
+       MUIM_Dataspace_Clear = $8042b6c9;
+    { V11  }
+       MUIM_Dataspace_Find = $8042832c;
+    { V11  }
+       MUIM_Dataspace_Merge = $80423e2b;
+    { V11  }
+       MUIM_Dataspace_ReadIFF = $80420dfb;
+    { V11  }
+       MUIM_Dataspace_Remove = $8042dce1;
+    { V11  }
+       MUIM_Dataspace_WriteIFF = $80425e8e;
+
+    type
+       tMUIP_Dataspace_Add = record
+            MethodID : LongWord;
+            data : APTR;
+            len : LONG;
+            id : LongWord;
+         end;
+       pMUIP_Dataspace_Add = ^tMUIP_Dataspace_Add;
+
+       tMUIP_Dataspace_Clear = record
+            MethodID : LongWord;
+         end;
+       pMUIP_Dataspace_Clear = ^tMUIP_Dataspace_Clear;
+
+       tMUIP_Dataspace_Find = record
+            MethodID : LongWord;
+            id : LongWord;
+         end;
+       pMUIP_Dataspace_Find = ^tMUIP_Dataspace_Find;
+
+       tMUIP_Dataspace_Merge = record
+            MethodID : LongWord;
+            dataspace : PObject_;
+         end;
+       pMUIP_Dataspace_Merge = ^tMUIP_Dataspace_Merge;
+
+       tMUIP_Dataspace_ReadIFF = record
+            MethodID : LongWord;
+            handle : Pointer;//PIFFHandle;
+         end;
+       pMUIP_Dataspace_ReadIFF = ^tMUIP_Dataspace_ReadIFF;
+
+       tMUIP_Dataspace_Remove = record
+            MethodID : LongWord;
+            id : LongWord;
+         end;
+       pMUIP_Dataspace_Remove = ^tMUIP_Dataspace_Remove;
+
+       tMUIP_Dataspace_WriteIFF = record
+            MethodID : LongWord;
+            handle : Pointer; //PIFFHandle;
+            type_ : LongWord;
+            id : LongWord;
+         end;
+       pMUIP_Dataspace_WriteIFF = ^tMUIP_Dataspace_WriteIFF;
+
+    { Attributes  }
+    { V11 i.. APTR               }
+
+    const
+       MUIA_Dataspace_Pool = $80424cf9;
+    {                                                                           }
+    {  Configdata                                                               }
+    {                                                                           }
+
+
+    const
+       MUIC_Configdata : PChar = 'Configdata.mui';
+
+    { Methods  }
+    { Attributes  }
+    {                                                                           }
+    {  Dtpic                                                                    }
+    {                                                                           }
+
+
+    const
+       MUIC_Dtpic : PChar = 'Dtpic.mui';
+    { Attributes  }
+    {                                        }
+    { End of automatic header file creation  }
+    {                                        }
+    {
+       Structures and Macros for creating custom classes.
+                                                                             }
+    {
+       GENERAL NOTES:
+
+       - Everything described in this header file is only valid within
+         MUI classes. You may never use any of these things out of
+         a class, e.g. in a traditional MUI application.
+
+       - Except when otherwise stated, all structures are strictly read only.
+     }
+    { Global information for every object  }
+    { ... private data follows ...  }
+
+    type
+       tMUI_GlobalInfo = record
+            priv0 : LongWord;
+            mgi_ApplicationObject : PObject_;
+         end;
+       pMUI_GlobalInfo = ^tMUI_GlobalInfo;
+
+    { Instance data of notify class  }
+       tMUI_NotifyData = record
+            mnd_GlobalInfo : PMUI_GlobalInfo;
+            mnd_UserData : LongWord;
+            mnd_ObjectID : LongWord;
+            priv1 : LongWord;
+            priv2 : LongWord;
+            priv3 : LongWord;
+            priv4 : LongWord;
+         end;
+       pMUI_NotifyData = ^tMUI_NotifyData;
+
+
+    { use this if a dimension is not limited.  }
+
+    const
+       MUI_MAXMAX = 10000;
+    { Hook message for custom layout  }
+    { type of message (see defines below)                       }
+    { list of this groups children, traverse with NextObject()  }
+    { results for MUILM_MINMAX                                  }
+    { size (and result) for MUILM_LAYOUT                        }
+
+    type
+       tMUI_LayoutMsg = record
+            lm_Type : LongWord;
+            lm_Children : PMinList;
+            lm_MinMax : tMUI_MinMax;
+            lm_Layout : record
+                 Width : LONG;
+                 Height : LONG;
+                 priv5 : LongWord;
+                 priv6 : LongWord;
+              end;
+         end;
+       pMUI_LayoutMsg = ^tMUI_LayoutMsg;
+
+    { MUI wants you to calc your min & max sizes  }
+
+    const
+       MUILM_MINMAX = 1;
+    { MUI wants you to layout your children       }
+       MUILM_LAYOUT = 2;
+    { return this if your hook doesn't implement lm_Type  }
+       MUILM_UNKNOWN = -(1);
+    { (partial) instance data of area class  }
+    { RenderInfo for this object  }
+    { Font  }
+    { min/max/default sizes  }
+    { position and dimension  }
+    { frame & innerspacing left offset  }
+    { frame & innerspacing top offset   }
+    { frame & innerspacing add. width   }
+    { frame & innerspacing add. height  }
+    { see definitions below  }
+    { ... private data follows ...  }
+
+    type
+       tMUI_AreaData = record
+            mad_RenderInfo : PMUI_RenderInfo;
+            priv7 : LongWord;
+            mad_Font : PTextFont;
+            mad_MinMax : tMUI_MinMax;
+            mad_Box : tIBox;
+            mad_addleft : BYTE;
+            mad_addtop : BYTE;
+            mad_subwidth : BYTE;
+            mad_subheight : BYTE;
+            mad_Flags : LongWord;
+         end;
+      pMUI_AreaData = ^tMUI_AreaData;
+
+    { Definitions for mad_Flags, other flags are private  }
+    { completely redraw yourself  }
+
+    const
+       MADF_DRAWOBJECT = 1 shl 0;
+    { only update yourself  }
+       MADF_DRAWUPDATE = 1 shl 1;
+    { MUI's draw pens  }
+       MPEN_SHINE = 0;
+       MPEN_HALFSHINE = 1;
+       MPEN_BACKGROUND = 2;
+       MPEN_HALFSHADOW = 3;
+       MPEN_SHADOW = 4;
+       MPEN_TEXT = 5;
+       MPEN_FILL = 6;
+       MPEN_MARK = 7;
+       MPEN_COUNT = 8;
+    { Mask for pens from MUI_ObtainPen()  }
+       MUIPEN_MASK = $0000ffff;
+
+
+    { Information on display environment  }
+    { valid between MUIM_Setup/MUIM_Cleanup  }
+    { valid between MUIM_Setup/MUIM_Cleanup  }
+    { valid between MUIM_Setup/MUIM_Cleanup  }
+    { valid between MUIM_Setup/MUIM_Cleanup  }
+    { valid between MUIM_Show/MUIM_Hide  }
+    { valid between MUIM_Show/MUIM_Hide  }
+    { valid between MUIM_Setup/MUIM_Cleanup  }
+    { ... private data follows ...  }
+
+
+
+    {
+       If mri_Flags & MUIMRI_RECTFILL, RectFill() is quicker
+       than Move()/Draw() for horizontal or vertical lines.
+       on the current display.
+     }
+
+    const
+       MUIMRI_RECTFILL = 1 shl 0;
+    {
+       If mri_Flags & MUIMRI_TRUECOLOR, display environment is a
+       cybergraphics emulated hicolor or true color display.
+     }
+       MUIMRI_TRUECOLOR = 1 shl 1;
+    {
+       If mri_Flags & MUIMRI_THINFRAMES, MUI uses thin frames
+       (1:1) apsect ratio instead of standard 2:1 frames.
+     }
+       MUIMRI_THINFRAMES = 1 shl 2;
+    {
+       If mri_Flags & MUIMRI_REFRESHMODE, MUI is currently
+       refreshing a WFLG_SIMPLEREFRESH window and is between
+       a BeginRefresh()/EndRefresh() pair.
+     }
+       MUIMRI_REFRESHMODE = 1 shl 3;
+    { the following macros can be used to get pointers to an objects
+       GlobalInfo and RenderInfo structures.  }
+
+    type
+       t__dummyXFC2__ = record
+            mnd : tMUI_NotifyData;
+            mad : tMUI_AreaData;
+         end;
+       p__dummyXFC2__ = ^t__dummyXFC2__;
+
+
+    const
+
+        MUIKEY_RELEASE = -2;
+        MUIKEY_NONE    = -1;
+        MUIKEY_PRESS   = 0;
+        MUIKEY_TOGGLE  = 1;
+        MUIKEY_UP      = 2;
+        MUIKEY_DOWN    = 3;
+        MUIKEY_PAGEUP  = 4;
+        MUIKEY_PAGEDOWN = 5;
+        MUIKEY_TOP      = 6;
+        MUIKEY_BOTTOM   = 7;
+        MUIKEY_LEFT     = 8;
+        MUIKEY_RIGHT    = 9;
+        MUIKEY_WORDLEFT = 10;
+        MUIKEY_WORDRIGHT = 11;
+        MUIKEY_LINESTART = 12;
+        MUIKEY_LINEEND   = 13;
+        MUIKEY_GADGET_NEXT = 14;
+        MUIKEY_GADGET_PREV = 15;
+        MUIKEY_GADGET_OFF  = 16;
+        MUIKEY_WINDOW_CLOSE = 17;
+        MUIKEY_WINDOW_NEXT  = 18;
+        MUIKEY_WINDOW_PREV  = 19;
+        MUIKEY_HELP         = 20;
+        MUIKEY_POPUP        = 21;
+        MUIKEY_COUNT        = 22;
+
+       MUIKEYF_PRESS = 1 shl MUIKEY_PRESS;
+       MUIKEYF_TOGGLE = 1 shl MUIKEY_TOGGLE;
+       MUIKEYF_UP = 1 shl MUIKEY_UP;
+       MUIKEYF_DOWN = 1 shl MUIKEY_DOWN;
+       MUIKEYF_PAGEUP = 1 shl MUIKEY_PAGEUP;
+       MUIKEYF_PAGEDOWN = 1 shl MUIKEY_PAGEDOWN;
+       MUIKEYF_TOP = 1 shl MUIKEY_TOP;
+       MUIKEYF_BOTTOM = 1 shl MUIKEY_BOTTOM;
+       MUIKEYF_LEFT = 1 shl MUIKEY_LEFT;
+       MUIKEYF_RIGHT = 1 shl MUIKEY_RIGHT;
+       MUIKEYF_WORDLEFT = 1 shl MUIKEY_WORDLEFT;
+       MUIKEYF_WORDRIGHT = 1 shl MUIKEY_WORDRIGHT;
+       MUIKEYF_LINESTART = 1 shl MUIKEY_LINESTART;
+       MUIKEYF_LINEEND = 1 shl MUIKEY_LINEEND;
+       MUIKEYF_GADGET_NEXT = 1 shl MUIKEY_GADGET_NEXT;
+       MUIKEYF_GADGET_PREV = 1 shl MUIKEY_GADGET_PREV;
+       MUIKEYF_GADGET_OFF = 1 shl MUIKEY_GADGET_OFF;
+       MUIKEYF_WINDOW_CLOSE = 1 shl MUIKEY_WINDOW_CLOSE;
+       MUIKEYF_WINDOW_NEXT = 1 shl MUIKEY_WINDOW_NEXT;
+       MUIKEYF_WINDOW_PREV = 1 shl MUIKEY_WINDOW_PREV;
+       MUIKEYF_HELP = 1 shl MUIKEY_HELP;
+       MUIKEYF_POPUP = 1 shl MUIKEY_POPUP;
+
+    { MUI_CustomClass returned by MUI_CreateCustomClass()  }
+    { use for whatever you want  }
+    { MUI has opened these libraries  }
+    { for you automatically. You can  }
+    { use them or decide to open      }
+    { your libraries yourself.        }
+    { pointer to super class    }
+    { pointer to the new class  }
+    { ... private data follows ...  }
+
+    type
+       tMUI_CustomClass = record
+            mcc_UserData : APTR;
+            mcc_UtilityBase : PLibrary;
+            mcc_DOSBase : PLibrary;
+            mcc_GfxBase : PLibrary;
+            mcc_IntuitionBase : PLibrary;
+            mcc_Super : PIClass;
+            mcc_Class : PIClass;
+         end;
+       pMUI_CustomClass = ^tMUI_CustomClass;
+
+var
+  MUIMasterBase : pLibrary;
+
+function MUI_NewObjectA(class_ : PChar; tags : pTagItem) : PObject_; syscall MUIMasterBase 5; 
+procedure MUI_DisposeObject(obj : PObject_); syscall MUIMasterBase 6;
+function MUI_RequestA(app : Pointer; win : Pointer; flags : LONGBITS; title : PChar; gadgets : PChar; format : PChar; params : Pointer) : LongInt; syscall MUIMasterBase 7;
+function MUI_AllocAslRequest(typ : LongWord; tags : pTagItem) : Pointer; syscall MUIMasterBase 8;
+function MUI_AslRequest(req : Pointer; tags : pTagItem) : LongBool; syscall MUIMasterBase 9;
+procedure MUI_FreeAslRequest(req : Pointer); syscall MUIMasterBase 10;
+function MUI_Error : LongInt; syscall MUIMasterBase 11;
+function MUI_SetError(errnum : LongInt) : LongInt; syscall MUIMasterBase 12;
+function MUI_GetClass(name : pCHar) : PIClass; syscall MUIMasterBase 13;
+procedure MUI_FreeClass(cl : PIClass); syscall MUIMasterBase 14;
+procedure MUI_RequestIDCMP(obj : PObject_; flags : LongWord); syscall MUIMasterBase 15;
+procedure MUI_RejectIDCMP(obj : PObject_; flags : LongWord); syscall MUIMasterBase 16;
+procedure MUI_Redraw(obj : PObject_; flags : LongWord); syscall MUIMasterBase 17;
+function MUI_CreateCustomClass(base : pLibrary; supername : PChar; supermcc : pMUI_CustomClass; datasize : LongInt; dispatcher : Pointer) : PMUI_CustomClass; syscall MUIMasterBase 18;
+function MUI_DeleteCustomClass(mcc : pMUI_CustomClass) : LongBool; syscall MUIMasterBase 19;
+function MUI_MakeObjectA(typ: LongInt; params : pLongWord) : PObject_; syscall MUIMasterBase 20;
+function MUI_Layout(obj: PObject_; l : LongInt; t : LongInt; w : LongInt; h : LongInt; flags : LongWord) : LongBool; syscall MUIMasterBase 21;
+function MUI_ObtainPen(mri: PMUI_RenderInfo; spec : pMUI_PenSpec; flags : LongWord) : LongInt; syscall MUIMasterBase 22;
+procedure MUI_ReleasePen(mri: PMUI_RenderInfo; pen : LongInt); syscall MUIMasterBase 23;
+function MUI_AddClipping(mri: PMUI_RenderInfo; l : smallint; t : smallint; w : smallint; h : smallint) : Pointer; syscall MUIMasterBase 24;
+procedure MUI_RemoveClipping(mri: PMUI_RenderInfo; h : Pointer); syscall MUIMasterBase 25;
+function MUI_AddClipRegion(mri: PMUI_RenderInfo; region : pRegion) : Pointer; syscall MUIMasterBase 26;
+procedure MUI_RemoveClipRegion(mri: PMUI_RenderInfo; region : Pointer); syscall MUIMasterBase 27;
+function MUI_BeginRefresh(mri: PMUI_RenderInfo; flags : LongWord) : LongBool; syscall MUIMasterBase 28;
+procedure MUI_EndRefresh(mri: PMUI_RenderInfo; flags : LongWord); syscall MUIMasterBase 29;
+
+
+(*
+** some procedures to get some information about our object
+*)
+
+function MUINotifyData(obj : APTR) : pMUI_NotifyData;
+function MUIAreaData(obj : APTR) : pMUI_AreaData;
+function MUIGlobalInfo(obj : APTR) : pMUI_GlobalInfo;
+function MUIUserData(obj : APTR) : Pointer ;
+function MUIRenderInfo(obj : APTR) : PMUI_RenderInfo;
+function MUIPen(pen : LongInt): LongInt;
+(*
+** some more specialized functions to retain information about special
+** object-data like rastport, window, etc.
+**
+** NOTE: These macros may only be used in custom classes and are
+** only valid if your class is inbetween the specified methods!
+*)
+
+function OBJ_App(obj : APTR) : PObject_;       (* valid between MUIM_Setup/Cleanup *)
+function OBJ_Win(obj : APTR) : PObject_;       (* valid between MUIM_Setup/Cleanup *)
+function OBJ_Dri(obj : APTR) : pDrawInfo;          (* valid between MUIM_Setup/Cleanup *)
+function OBJ_Screen(obj : APTR) : pScreen;         (* valid between MUIM_Setup/Cleanup *)
+function OBJ_Pens(obj : APTR) : pWord;             (* valid between MUIM_Setup/Cleanup *)
+function OBJ_Window(obj : APTR) : pWindow;         (* valid between MUIM_Show/Hide *)
+function OBJ_Rp(obj : APTR) : pRastPort;           (* valid between MUIM_Show/Hide *)
+function OBJ_Left(obj : APTR) : smallint;           (* valid during MUIM_Draw *)
+function OBJ_Top(obj : APTR) : smallint;            (* valid during MUIM_Draw *)
+function OBJ_Width(obj : APTR) : smallint;          (* valid during MUIM_Draw *)
+function OBJ_Height(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+function OBJ_Right(obj : APTR) : smallint;          (* valid during MUIM_Draw *)
+function OBJ_Bottom(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+function OBJ_AddLeft(obj : APTR) : smallint;        (* valid during MUIM_Draw *)
+function OBJ_AddTop(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+function OBJ_SubWidth(obj : APTR) : smallint;       (* valid during MUIM_Draw *)
+function OBJ_SubHeight(obj : APTR) : smallint;      (* valid during MUIM_Draw *)
+function OBJ_MLeft(obj : APTR) : smallint;          (* valid during MUIM_Draw *)
+function OBJ_MTop(obj : APTR) : smallint;           (* valid during MUIM_Draw *)
+function OBJ_MWidth(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+function OBJ_MHeight(obj : APTR) : smallint;        (* valid during MUIM_Draw *)
+function OBJ_MRight(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+function OBJ_MBottom(obj : APTR) : smallint;        (* valid during MUIM_Draw *)
+function OBJ_Font(obj : APTR) : pTextFont;         (* valid between MUIM_Setup/Cleanup *)
+function OBJ_MinWidth(obj : APTR) : LongWord;         (* valid between MUIM_Show/Hide *)
+function OBJ_MinHeight(obj : APTR) : LongWord;        (* valid between MUIM_Show/Hide *)
+function OBJ_MaxWidth(obj : APTR) : LongWord;         (* valid between MUIM_Show/Hide *)
+function OBJ_MaxHeight(obj : APTR) : LongWord;        (* valid between MUIM_Show/Hide *)
+function OBJ_DefWidth(obj : APTR) : LongWord;         (* valid between MUIM_Show/Hide *)
+function OBJ_DefHeight(obj : APTR) : LongWord;        (* valid between MUIM_Show/Hide *)
+function OBJ_Flags(obj : APTR) : LongWord;
+
+function OBJ_Between(a,x,b : smallint): boolean;
+function OBJ_IsInObject(x,y : smallint; obj : PObject_): boolean;
+
+function MUIV_Window_AltHeight_MinMax(p : LongInt) : LongInt;
+function MUIV_Window_AltHeight_Visible(p : LongInt) : LongInt;
+function MUIV_Window_AltHeight_Screen(p : LongInt) : LongInt;
+function MUIV_Window_AltTopEdge_Delta(p : LongInt) : LongInt;
+function MUIV_Window_AltWidth_MinMax(p : LongInt) : LongInt;
+function MUIV_Window_AltWidth_Visible(p : LongInt) : LongInt;
+function MUIV_Window_AltWidth_Screen(p : LongInt) : LongInt;
+function MUIV_Window_Height_MinMax(p : LongInt) : LongInt;
+function MUIV_Window_Height_Visible(p : LongInt) : LongInt;
+function MUIV_Window_Height_Screen(p : LongInt) : LongInt;
+function MUIV_Window_TopEdge_Delta(p : LongInt) : LongInt;
+function MUIV_Window_Width_MinMax(p : LongInt) : LongInt;
+function MUIV_Window_Width_Visible(p : LongInt) : LongInt;
+function MUIV_Window_Width_Screen(p : LongInt) : LongInt;
+
+{
+ Functions and procedures with array of const go here
+}
+function MUI_AllocAslRequestTags(_type : longword; const tags : Array Of Const) : Pointer;
+function MUI_AslRequestTags(req : Pointer; const tags : Array Of Const) : LongBool;
+function MUI_MakeObject(_type : LongInt; const params : Array Of Const) : pLongWord;
+function MUI_NewObject(a0arg : pCHAR; const tags : Array Of Const) : pLongWord;
+function MUI_Request(app : Pointer; win : Pointer; flags : longword; title : pCHAR; gadgets : pCHAR; format : pCHAR; const params : Array Of Const) : LongInt;
+
+
+
+{This is a variable that knows how the unit is compiled}
+var
+    MUIMASTERIsCompiledHow : LongInt;
+
+implementation
+
+uses
+  tagsarray,longarray;
+
+function MUINotifyData(obj : APTR) : pMUI_NotifyData;
+begin
+    MUINotifyData := pMUI_NotifyData(@p__dummyXFC2__(obj)^.mnd);
+end;
+
+function MUIAreaData(obj : APTR) : pMUI_AreaData;
+begin
+    MUIAreaData := pMUI_AreaData(@p__dummyXFC2__(obj)^.mad);
+end;
+
+function MUIGlobalInfo(obj : APTR) : pMUI_GlobalInfo;
+begin
+    MUIGlobalInfo := pMUI_GlobalInfo(p__dummyXFC2__(obj)^.mnd.mnd_GlobalInfo);
+end;
+
+function MUIUserData(obj : APTR) : Pointer ;
+begin
+    MUIUserData := Pointer(p__dummyXFC2__(obj)^.mnd.mnd_GlobalInfo);
+end;
+
+function MUIRenderInfo(obj : APTR) : PMUI_RenderInfo;
+begin
+    MUIRenderInfo := PMUI_RenderInfo(p__dummyXFC2__(obj)^.mad.mad_RenderInfo);
+end;
+
+function MUIPen(pen : LongInt): LongInt;
+begin
+    MUIPen := LongInt(pen*MUIPEN_Mask);
+end;
+
+function OBJ_App(obj : APTR) : PObject_;       (* valid between MUIM_Setup/Cleanup *)
+begin
+    OBJ_App := pMUI_GlobalInfo(obj)^.mgi_ApplicationObject;
+end;
+
+function OBJ_Win(obj : APTR) : PObject_;       (* valid between MUIM_Setup/Cleanup *)
+begin
+    OBJ_Win := PMUI_RenderInfo(obj)^.mri_WindowObject;
+end;
+
+function OBJ_Dri(obj : APTR) : pDrawInfo;          (* valid between MUIM_Setup/Cleanup *)
+begin
+    OBJ_Dri := PMUI_RenderInfo(obj)^.mri_DrawInfo;
+end;
+
+function OBJ_Screen(obj : APTR) : pScreen;         (* valid between MUIM_Setup/Cleanup *)
+begin
+    OBJ_Screen := PMUI_RenderInfo(obj)^.mri_Screen;
+end;
+
+function OBJ_Pens(obj : APTR) : pWord;      (* valid between MUIM_Setup/Cleanup *)
+begin
+    OBJ_Pens := PMUI_RenderInfo(obj)^.mri_Pens;
+end;
+
+function OBJ_Window(obj : APTR) : pWindow;         (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_Window := PMUI_RenderInfo(obj)^.mri_Window;
+end;
+
+function OBJ_Rp(obj : APTR) : pRastPort;           (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_Rp := PMUI_RenderInfo(obj)^.mri_RastPort;
+end;
+
+function OBJ_Left(obj : APTR) : smallint;           (* valid during MUIM_Draw *)
+begin
+    OBJ_Left := MUIAreaData(obj)^.mad_Box.Left;
+end;
+
+function OBJ_Top(obj : APTR) : smallint;            (* valid during MUIM_Draw *)
+begin
+    OBJ_Top := MUIAreaData(obj)^.mad_Box.Top;
+end;
+
+function OBJ_Width(obj : APTR) : smallint;          (* valid during MUIM_Draw *)
+begin
+    OBJ_Width := MUIAreaData(obj)^.mad_Box.Width;
+end;
+
+function OBJ_Height(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+begin
+    OBJ_Height := MUIAreaData(obj)^.mad_Box.Height;
+end;
+
+function OBJ_Right(obj : APTR) : smallint;          (* valid during MUIM_Draw *)
+begin
+    OBJ_Right := OBJ_Left(obj) + OBJ_Width(obj) -1;
+end;
+
+function OBJ_Bottom(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+begin
+    OBJ_Bottom := OBJ_Top(obj) + OBJ_Height(obj) -1;
+end;
+
+function OBJ_AddLeft(obj : APTR) : smallint;        (* valid during MUIM_Draw *)
+begin
+    OBJ_AddLeft := MUIAreaData(obj)^.mad_AddLeft;
+end;
+
+function OBJ_AddTop(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+begin
+    OBJ_AddTop := MUIAreaData(obj)^.mad_AddTop;
+end;
+
+function OBJ_SubWidth(obj : APTR) : smallint;       (* valid during MUIM_Draw *)
+begin
+    OBJ_SubWidth := MUIAreaData(obj)^.mad_SubWidth;
+end;
+
+function OBJ_SubHeight(obj : APTR) : smallint;      (* valid during MUIM_Draw *)
+begin
+    OBJ_SubHeight := MUIAreaData(obj)^.mad_SubHeight;
+end;
+
+function OBJ_MLeft(obj : APTR) : smallint;          (* valid during MUIM_Draw *)
+begin
+    OBJ_MLeft := OBJ_Left(obj) + OBJ_AddLeft(obj);
+end;
+
+function OBJ_MTop(obj : APTR) : smallint;           (* valid during MUIM_Draw *)
+begin
+    OBJ_MTop := OBJ_Top(obj) + OBJ_AddTop(obj);
+end;
+
+function OBJ_MWidth(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+begin
+    OBJ_MWidth := OBJ_Width(obj) -OBJ_SubWidth(obj);
+end;
+
+function OBJ_MHeight(obj : APTR) : smallint;        (* valid during MUIM_Draw *)
+begin
+    OBJ_MHeight := OBJ_Height(obj) - OBJ_SubHeight(obj);
+end;
+
+function OBJ_MRight(obj : APTR) : smallint;         (* valid during MUIM_Draw *)
+begin
+    OBJ_MRight := OBJ_MLeft(obj) + OBJ_MWidth(obj) -1;
+end;
+
+function OBJ_MBottom(obj : APTR) : smallint;        (* valid during MUIM_Draw *)
+begin
+    OBJ_MBottom := OBJ_MTop(obj) + OBJ_MHeight(obj) -1;
+end;
+
+function OBJ_Font(obj : APTR) : pTextFont;         (* valid between MUIM_Setup/Cleanup *)
+begin
+    OBJ_Font := MUIAreaData(obj)^.mad_Font;
+end;
+
+function OBJ_MinWidth(obj : APTR) : LongWord;         (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_MinWidth := MUIAreaData(obj)^.mad_MinMax.MinWidth;
+end;
+
+function OBJ_MinHeight(obj : APTR) : LongWord;        (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_MinHeight := MUIAreaData(obj)^.mad_MinMax.MinHeight;
+end;
+
+function OBJ_MaxWidth(obj : APTR) : LongWord;         (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_maxWidth := MUIAreaData(obj)^.mad_MinMax.MaxWidth;
+end;
+
+function OBJ_MaxHeight(obj : APTR) : LongWord;        (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_maxHeight := MUIAreaData(obj)^.mad_MinMax.MaxHeight;
+end;
+
+function OBJ_DefWidth(obj : APTR) : LongWord;         (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_DefWidth := MUIAreaData(obj)^.mad_MinMax.DefWidth;
+end;
+
+function OBJ_DefHeight(obj : APTR) : LongWord;        (* valid between MUIM_Show/Hide *)
+begin
+    OBJ_DefHeight := MUIAreaData(obj)^.mad_MinMax.DefHeight;
+end;
+
+function OBJ_Flags(obj : APTR) : LongWord;
+begin
+    OBJ_Flags := MUIAreaData(obj)^.mad_Flags;
+end;
+
+(*
+** 2 useful procedures for testing if some coordinates are inside your object
+** (converted from the ones in class3.c. So look there how to use... )
+*)
+
+function OBJ_Between(a,x,b : smallint): boolean;
+begin
+    OBJ_Between := ((x>=a) and (x<=b));
+end;
+
+function OBJ_IsInObject(x,y : smallint; obj : PObject_): boolean;
+begin
+    OBJ_IsInObject := (OBJ_Between(OBJ_MLeft(obj),x,OBJ_MRight(obj))
+        and OBJ_Between(OBJ_MTop(obj),y,OBJ_MBottom(obj)));
+end;
+
+function MUIV_Window_AltHeight_MinMax(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltHeight_MinMax := (0 - p);
+end;
+
+function MUIV_Window_AltHeight_Visible(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltHeight_Visible := (-100 - (p));
+end;
+
+function MUIV_Window_AltHeight_Screen(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltHeight_Screen := (-200 - (p));
+end;
+
+function MUIV_Window_AltTopEdge_Delta(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltTopEdge_Delta := (-3 - (p));
+end;
+
+function MUIV_Window_AltWidth_MinMax(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltWidth_MinMax := 0 - p;
+end;
+
+function MUIV_Window_AltWidth_Visible(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltWidth_Visible := (-100 - (p));
+end;
+
+function MUIV_Window_AltWidth_Screen(p : LongInt) : LongInt;
+begin
+    MUIV_Window_AltWidth_Screen := (-200 - (p));
+end;
+
+function MUIV_Window_Height_MinMax(p : LongInt) : LongInt;
+begin
+    MUIV_Window_Height_MinMax := 0 - p;
+end;
+
+function MUIV_Window_Height_Visible(p : LongInt) : LongInt;
+begin
+    MUIV_Window_Height_Visible := (-100 - (p));
+end;
+
+function MUIV_Window_Height_Screen(p : LongInt) : LongInt;
+begin
+    MUIV_Window_Height_Screen := (-200 - (p));
+end;
+
+function MUIV_Window_TopEdge_Delta(p : LongInt) : LongInt;
+begin
+    MUIV_Window_TopEdge_Delta := (-3 - (p));
+end;
+
+function MUIV_Window_Width_MinMax(p : LongInt) : LongInt;
+begin
+    MUIV_Window_Width_MinMax := 0 - p;
+end;
+
+function MUIV_Window_Width_Visible(p : LongInt) : LongInt;
+begin
+    MUIV_Window_Width_Visible := (-100 - (p));
+end;
+
+function MUIV_Window_Width_Screen(p : LongInt) : LongInt;
+begin
+    MUIV_Window_Width_Screen := (-200 - (p));
+end;
+
+{
+ Functions and procedures with array of const go here
+}
+function MUI_AllocAslRequestTags(_type : longword; const tags : Array Of Const) : Pointer;
+begin
+    MUI_AllocAslRequestTags := MUI_AllocAslRequest(_type , readintags(tags));
+end;
+
+function MUI_AslRequestTags(req : Pointer; const tags : Array Of Const) : LongBool;
+begin
+    MUI_AslRequestTags := MUI_AslRequest(req , readintags(tags));
+end;
+
+function MUI_MakeObject(_type : LongInt; const params : Array Of Const) : pLongWord;
+begin
+    MUI_MakeObject := MUI_MakeObjectA(_type , readinlongs(params));
+end;
+
+function MUI_NewObject(a0arg : pCHAR; const tags : Array Of Const) : pLongWord;
+begin
+    MUI_NewObject := MUI_NewObjectA(a0arg , readintags(tags));
+end;
+
+function MUI_Request(app : Pointer; win : Pointer; flags : longword; title : pCHAR; gadgets : pCHAR; format : pCHAR; const params : Array Of Const) : LongInt;
+begin
+    MUI_Request := MUI_RequestA(app , win , flags , title , gadgets , format , readintags(params));
+end;
+
+const
+    { Change VERSION and LIBVERSION to proper values }
+
+    VERSION : string[2] = '0';
+    LIBVERSION : longword = 0;
+
+initialization
+  MUIMasterBase := OpenLibrary(MUIMASTER_NAME,LIBVERSION);
+finalization
+  CloseLibrary(MUIMasterBase);
+end.