@ Types & Structures... 
:TJump
^Type TJump

 Come From : ~Unit MOS_ASM~

 Type TJump=Record                              {*To store Sp, Bp, Add*}
      SpReg,
      BpReg :Word;
      JmpPt :Pointer;
      End;
:TOnglet
^Type TOnglet

 Come From : ~Unit MOS_OCG~

 Type TOnglet=Record                      {*Onglet structure*}
      X1,Y1,X2,Y2 :Integer;               {*Box coordinates*}
      STxt        :Integer;               {*Labels Size Y*}
      QttO        :Byte;                  {*Quantity of Onglets*}
      No          :Shortint;              {*Current Onglet Number*}
      COa,COi     :Integer;               {*Onglet colors (Activated or no)*}
      TCT         :String;                {*Onglet titles*}
      Id          :Word;                  {*Id Onglets*}
      {*Bit 0  $0001 = Freezed            Freezed Onglet*}
      {*Bit 1  $0002 = Invisible Onglet   Invisible Onglet*}
      {*Bit 2  $0004 = Hand Pointer       Hand Mouse Pointer on title*}
      End;
:TCombo
^Type TCombo

 Come From : ~Unit MOS_OCG~

 TCombo=Record                            {*Combo Box definition*}
      X1,Y1       :Integer;               {*Gadget position*}
      Sx          :Integer;               {*Gadget width*}
      Col1,Col2   :Longint;               {*Gadget colors*}
      Col3        :Longint;               {*List color*}
      Selected    :Integer;               {*Item selected*}
      But         :TButton;               {*Pointer to the Button Structure*}
      Inp         :TInputText;            {*Pointer to the Command Structure*}
      List        :TList;                 {*Pointer to the List Structure*}
      ListName    :String[12];            {*Filename for the List file*}
      QttMaxItems :Integer;               {*Maximum numbers of Items in List*}
      Win         :TWindow;               {*Pointer to the Window Structure*}
      Id          :Word;                  {*Id Combo Box*}
      {*Bit 0  $0001 : 1 = No InputText. Select only in List*}
      {*Bit 1  $0002 : 1 = Freezed Gadget*}
      {*Bit 2  $0004 : 1 = Invisible Gadget*}
      {*Bit 3  $0008 : 1 = Combo list movable*}
      {*Bit 4  $0010 : 1 = Hand Pointer on button*}
      {*Bit 5  $0020 : 1 = Adjust List-box to horizontal optimal size*}
      {*Bit 6  $0040 : 1 = Adjust List-box to vertical optimal size*}
      {*Bit 7  $0080 : 1 = Enable preselection item*}
      {*Bit 8  $0100 : 1 = Sort list items*}
      {*Bit 9  $0200 : 1 = Enable rotation in list selection*}
      End;

:TBMPHeader
^Type TBMPHeader

 Come From : ~Unit MOS_BMP~

 Type TBMPHeader=Record   { Header of a BMP file}
        ID    : Array[1..2] of char; { 'BM' for a Windows BitMaP }
        FSize : LongInt;  { Size of file }
        Ver   : LongInt;  { BMP version (?), currently 0 }
        Image : LongInt;  { Offset of image into file }
        Misc  : LongInt;  { Unknown, appears to be 40 for all files }
        Width : LongInt;  { Width of image }
        Height: LongInt;  { Height of image }
        Num   : Word;     { Not sure,possibly number of images or planes (1) }
        Bits  : Word;     { Number of bits per pixel }
        Comp  : LongInt;  { Type of compression, 0 = uncompressed, 1,2 = RLE }
        ISize : LongInt;  { Size of image in bytes }
        XRes  : LongInt;  { X dots per metre }
        YRes  : LongInt;  { Y dots per metre }
        PSize : LongInt;  { Palette size (number of colours) If not zero }
        Res   : LongInt;  { Probably reserved, currently 0 }
      End;                { 54 bytes }
:TBMPPalette256
^Type TBMPPalette256

 Come From : ~Unit MOS_BMP~

      TBMPPalette256 = Record { BMP uses a 4 bytes for the palette }
        b,g,r,x : Byte;       { Last byte is not used }
      End;



:TMenu
^Type TMenu

 Come From : ~Unit MOS_MEN~

 Type TMenu = Record                      {*Menus structure*}
      TbMen :Array[1..Max_Menu,1..Max_Menu_Points] of String[Max_Length_Points];
      TbLen :Array[1..Max_Menu] of Word;  {*Menus length array*}
      TbSiz :Array[1..Max_Menu] of Word;  {*Menus width array*}
      TbId  :Array[1..Max_Menu,1..Max_Menu_Points] of Byte;{*Definition bits*}
      TbKey :Array[1..Max_Menu,1..Max_Menu_Points] of Byte;{*Hotkey for each menu point*}
      End;


:TSaveScreen
^Type TSaveScreen

 Come From : ~Unit MOS_GFX~

 Type TSaveScreen = Record            {*Type for Save/Restore_Screen*}
        What_save     : Word;         {*Bits of what you want to save*}
        ModeG         : Word;         {*GFX Mode*}
        Palette256    : Tpalette256;  {*256 colors palette*}
        ImageSwap     : Tswap;        {*Picture displayed on screen*}
        MouseX,MouseY : Word;         {*Mouse coordinates*}
        ViewPort      : TViewPortType;{*VESA_SetViewPort parameters*}
      End;
:TCHRHeader
^Type TCHRHeader

 Come From : ~Unit MOS_GPH~

 Type TCHRHeader = Record        {* Header of a CHR file*}
        Prefix      :Array[1..$80] of Char; {*Header*}
        Sig         :char;	{* SIGNATURE byte                        *}
        Nchrs       :Integer;	{* number of characters in file          *}
        Mystery     :char;       {* Currently Undefined                   *}
        First	   :byte;    	{* first character in file               *}
        Cdefs	   :Integer;    {* offset to char definitions            *}
        Scan_Flag   :char;	{* True if set is scanable               *}
        Org_To_Cap  :Shortint;	{* Height from origin to top of capitol  *}
        Org_To_Base :Shortint;	{* Height from origin to baseline        *}
        Org_To_Dec  :Shortint;	{* Height from origin to bot of decender *}
        FntName     :Array[1..4] of char;{* Four character name of font   *}
        Unused      :char;       {* Currently undefined                   *}
      End;
:TCHRFont
^Type TCHRFont

 Come From : ~Unit MOS_GPH~

      TCHRFont = Record        {*CHR font informations*}
        Font_Name    :String[80]; {* Name and path of the font              *}
        Org_to_cap   :Integer; {* Height from origin to top of capitol      *}
        Org_to_base  :Integer; {* Height from origin to baseline            *}
        Org_to_dec   :Integer; {* Height from origin to bot of decender     *}
        Num_chrs     :Integer; {* Four character name of font               *}
        First        :Byte;    {* First character in file                   *}
        Direction    :Byte;    {* Direction : horizontal (0) or vertical (1)*}
        Char_Width   :Array[0..255] of Byte;  {* Character Width Table	   *}
        Offset       :Array[0..255] of Integer;
        RFontSize     :Real;   {*1..9 : Font Size on Screen                 *}
        P_Font       :Pointer;
        Size_P_Font  :Word;
      End;
:TPalette256
^Type TPalette256

 Come From : ~Unit MOS_GPH~

      TPalette256 = Array[0..255,1..3] of Byte;  {*256 Red/Green/Blue (RGB)*}
:TLineSettingsType
^Type TLineSettingsType

 Come From : ~Unit MOS_GPH~

      TLineSettingsType = Record  {*Type for definition of Lines*}
        LineStyle : Word;
        Pattern   : Word;
        Thickness : Word;
      End;
:TPatternSettingsType
^Type TPatternSettingsType

 Come From : ~Unit MOS_GPH~

      TPatternSettingsType = Record {*Type pour definition of Pattern*}
        Pattern:Word;
        Color:Word;
      End;
:TViewPortType
^Type TViewPortType

 Come From : ~Unit MOS_GPH~

      TViewPortType = Record   {*Set View Port parameters*}
        x1, y1, x2, y2 : integer;
        Clip           : Boolean;
      End;
:TPointType
^Type TPointType

 Come From : ~Unit MOS_GPH~

      TPointType = Record    {*Coordinates*}
          X, Y : integer;
      End;
:TFillPatternType
^Type TFillPatternType

 Come From : ~Unit MOS_GPH~

      TFillPatternType = array[1..8] of byte;

:TLocate
^Type TLocate

 Come From : ~Unit MOS_KBD~

 TLocate=Record                                       {*Position structure*}
     X,Y                 :Integer;                 {*2D Position*}
     Style               :Integer;                 {*Cursor style*}
     Blink               :Integer;                 {*Speed blink*}
     T1,T2,T3,T4         :Word;                    {*Time variables*}
     N1,N2,N3,N4         :Word;
     End;
:TListItem
^Type TListItem

 Come From : ~Unit MOS_LIS~

 TListItem=Record                        {*Item Structure*}
    Item                 :String;        {*Item string*}
    Tag                  :Shortint;      {*Tag value*}
    User                 :Byte;          {*Free variable for user*}
    Color                :Byte;          {*Pen color line*}
    BkColor              :Shortint;      {*Background color line*}
    Id                   :Word;          {*Bits configuration*}
        {  0  0001 :  1 = Item Freezed / 0 = Enabled}
        {  1  0002 :  1 = Draw separator line (Used by Menus)}
    End;
:TListColumn
^Type TListColumn

 Come From : ~Unit MOS_LIS~

 TListColumn=Record                      {*Column Structure*}
    Number               :Byte;          {*Column number*}
    Size                 :Integer;       {*Column width (Pixels)*}
    OldSize              :Integer;       {*Column width for Hidden column*}
    Justif               :Byte;          {*Text position Id*}
    User                 :Byte;          {*Free variable for user*}
    Id                   :Word;          {*Bits configuration*}
        {  0  0001 :  1 = Enable column modifications}
        {  1  0002 :  1 = Display Associated icons for files items}
        {  2  0004 :  1 = Use special column color}
        {  3  0008 :  1 = Column not displayed}
    End;
:TList
^Type TList

 Come From : ~Unit MOS_LIS~

 TList=Record                            {*List Structure*}
    Title                :String;        {*List title (define columns)*}
    Path                 :String;        {*File path for "File column"*}
    X1,Y1,X2,Y2          :Integer;       {*List box coordinates*}
    Color                :Integer;       {*Background color for list*}
    Color_Line           :Integer;       {*Alternate color for lines*}
    Sort_Sens            :Byte;          {*Sort direction for the list*}
    Sort_Column          :Byte;          {*Column number to sort the list*}
    Qtt_Items            :Longint;       {*Number of items in list*}
    Qtt_Max_Items        :Longint;       {*Maximum number of items in list*}
    Qtt_Tagged_Items     :Longint;       {*Number of tagged items*}
    Qtt_Show_Items       :Integer;       {*Number of displayable items*}
    Qtt_Columns          :Byte;          {*Number of columns*}
    Pos_Item             :Longint;       {*Last clicked item indice*}
    Pos_Column           :Byte;          {*Number of the selected column*}
    Pos_Show             :Longint;       {*First displayable item indice*}
    Pos_Taquet           :Byte;          {*Number of the selected taquet*}
    Item_SizeY           :Byte;          {*Height of an item (Pixels)*}
    FontType             :String[12];    {*Defined Font for the List*}
    FontSize             :Byte;
    Mouse_InList         :Boolean;       {*Mouse is clicked over the box list*}
    Mouse_OverList       :Boolean;       {*Mouse is over the box list*}
    MOx,MOy              :Integer;       {*Old Mouse coordinates*}
    OldI,OldC            :Longint;       {*Old Indice,Column for the Cell on Mouse*}
    Sh,Sv                :TSlider;       {*Sliders pointers*}
    IB                   :TInfoBox;      {*Infobox pointers*}
    ASC                  :Array[1..Max_Col] of TListColumn;{*Columns array*}
 
    List                 :TXMSTab;       {*Pointer to XMS array*}
 
    Id                   :Word;          {*Bits configuration*}
        {  0  0001 :  1 = Display List title}
        {  1  0002 :  1 = Sensitive items selection. No Multiselection!}
        {  2  0004 :  1 = Columns are movable}
        {  3  0008 :  1 = Columns size modifiable}
        {  4  0010 :  1 = List Freezed / 0 = Activated}
        {  5  0020 :  1 = Multiselection Items Enable / Monoselection}
        {  6  0040 :  1 = Select item when mouse is unclicked}
        {  7  0080 :  1 = Rename Items Enable}
        {  8  0100 :  1 = Move The Whole List When Horizontal Slider is Moved}
        {  9  0200 :  1 = Select Items Enable}
        { 10  0400 :  1 = Show columns separator}
        { 11  0800 :  1 = Alternates colors for lines}
        { 12  1000 :  1 = Enable Items sorting by user}
        { 13  2000 :  1 = Show grid (Using Lightgray Color)}
        { 14  4000 :  1 = Help with an Info-Box}
        { 15  8000 :  1 = Rotation in list when select item}
    IdMore               :Word;          {*Bits configuration 2nd*}
        {  0  0001 :  1 = Don't draw list border}
        {  1  0002 :  1 = Disable F5 key}
        {  2  0004 :  1 = Display Hand pointer on selectable items}
        {  3  0008 :  1 = Disable ENTER Key}
    End;

:TPosMse
^Type TPosMse

 Come From : ~Unit MOS_MSE~

 Type TPosMse=Record                      {*Mouse position Multiple uses *}
      X,Y          :Integer;
      End;
:TAction
^Type TAction

 Come From : ~Unit MOS_MSE~

      TAction=Record
      X,Y          :Word;                 {*New mouse coordinantes*}
      XOld,YOld    :Word;                 {*Old mouse coordinantes*}
      Ga,Mi,Dr     :Boolean;              {*Mouse Buttons Actions*}
      End;
:TLightBox
^Type TLightBox

 Come From : ~Unit MOS_TOO~

 Type TLightBox=Record                   {*Light-Box type*}
      X1,Y1,X2,Y2:Integer;               {*Light-Box coordinates*}
      Xo,Yo      :Integer;               {*Old mouse coordinates*}
      End;
:TCoordinates
^Type TCoordinates

 Come From : ~Unit MOS_TOO~

    TCoordinates=Record                  {*Coordinates Structure*}
    X1,Y1,X2,Y2    :Integer;
    End;
:TClock
^Type TClock

 Come From : ~Unit MOS_TOO~

    TClock=Record                        {*TClock type*}
    Cx,Cy          :Integer;             {*Center of the clock*}
    Sx,Sy          :Integer;             {*Radius X,Y of the clock*}
    Fs             :Integer;             {*Size factor...*}
    Show           :Boolean;             {*DIGITAL : Display or not*}
    OldS           :Word;                {*DIGITAL : Old Seconds*}
    Inter          :String[1];           {*DIGITAL : Between 2 numbers*}
    Cur            :Array[1..4] of Word;
    Old            :Array[1..3] of String[2];
    Oh,Om,Os,Od    :Word;                {*Latest hour*}
    Px,Py          :Integer;
    Aiguille       :Array[1..5] of TPointType;
    IT,CT          :Longint;             {*Time_TestTimer : Initial and current time*}
    End;


:TRedBook
^Type TRedBook

 Come From : ~Unit MOS_MED~

         TRedBook = RECORD
                 Frame, Second, Minute, Unused: Byte;
         END;
:TTrack
^Type TTrack

 Come From : ~Unit MOS_MED~

         TTrack = RECORD
                 Start, Finish: TRedBook;
         END;
:TDeviceHeader
^Type TDeviceHeader

 Come From : ~Unit MOS_MED~

         TDeviceHeader = RECORD
                 NextDriver: Pointer;
                 Attribute, StratEntry, IntEntry: Word;
                 Name: array[0..7] of Char;
                 Res: Word;
                 Letter, Units: Byte;
         END;
:TDevice
^Type TDevice

 Come From : ~Unit MOS_MED~

         TDevice = RECORD
                 Subunit: Byte;
                 Header: Pointer;
         END;
:TRequestHeader
^Type TRequestHeader

 Come From : ~Unit MOS_MED~

         TRequestHeader = RECORD
                 Length,        Subunit, Command: Byte;
                 Status: Word;
                 Res: array[0..7] of Byte;
         END;
:TPlayRequest
^Type TPlayRequest

 Come From : ~Unit MOS_MED~

         TPlayRequest = RECORD
                 Header: TRequestHeader;
                 Addressing: Byte;
                 Start, Length: LongInt;
         END;
:TIOCTLRequest
^Type TIOCTLRequest

 Come From : ~Unit MOS_MED~

         TIOCTLRequest = RECORD
                 Header: TRequestHeader;
                 Media: Byte;
                 Address: Pointer;
                 Length,        Start: Word;
                 Res: Pointer;
         END;
:TQChannel
^Type TQChannel

 Come From : ~Unit MOS_MED~

         TQChannel = RECORD
                 Command, CTRL_ADR, Track,        Point: Byte;
                 Min, Sec, Frame, Zero, AMin, ASec, AFrame: Byte;
         END;
:TDeviceStatus
^Type TDeviceStatus

 Come From : ~Unit MOS_MED~

         TDeviceStatus = RECORD
                 Command: Byte;
                 Status: LongInt;
         END;
:TCommand
^Type TCommand

 Come From : ~Unit MOS_MED~

         TCommand = RECORD
                 Command: Byte;
         END;
:TDiskInfo
^Type TDiskInfo

 Come From : ~Unit MOS_MED~

         TDiskInfo = RECORD
                 Command: Byte;
                 LowTrack, HighTrack: Byte;
                 LeadOut: TRedBook;
         END;
:TTrackInfo
^Type TTrackInfo

 Come From : ~Unit MOS_MED~

         TTrackInfo = RECORD
                 Command, Track: Byte;
                 Start: TRedBook;
                 Control: Byte;
         END;
 TYPE
:TCD
^Type TCD

 Come From : ~Unit MOS_MED~

         TCD = OBJECT
             private
                 Drive,                 { CD-ROM drive }
                 Letter: Byte;          { drive letter }
                 Header: ^TDeviceHeader;
                 Subunit: Byte;
                 Name: String[8]; { name of driver }
                 Handle: Word;
                 Tracks: array[1..64] of TTrack;        { track info }
                 Status: Word;        { drive status }
 
                 FUNCTION RedToHSG(Redbook: TRedbook): LongInt;
                 PROCEDURE HSGToRed(HSG: Longint; VAR Redbook: TRedbook);
                 FUNCTION Drives: Byte;     { # of CD-ROM drives }
                 FUNCTION Version: Word;    { MSCDEX version }
                 PROCEDURE GetHandle;
                 PROCEDURE GetSubUnit;
                 PROCEDURE GetDriveLetter;
                 PROCEDURE GetDriverName;
                 FUNCTION MediaChanged: Byte;{ disc ready/different/etc }
             public
                   LowTrack, HighTrack, CurTrack: Byte;
                   cMin, cSec, cFrame,      { track time }
                   tMin, tSec, tFrame,      { track length }
                   dMin, dSec, dFrame: Byte;{ disc time }
 
                   PROCEDURE Open;     {Eject le CD}
                   PROCEDURE Close;   {Ferme le tiroir}
                   PROCEDURE Done;
                   PROCEDURE PlayTrack(Track: Byte);
                   PROCEDURE Stop;            {stope le cd}
                   PROCEDURE Pause ;
                   PROCEDURE Resume ;
                   PROCEDURE GetTracks;  { get track info }
                   PROCEDURE GetPosition;{ get play position }
                   PROCEDURE GetStatus;     { set Status field}
 
                   FUNCTION Time(M, S, F: Byte): String; { Redbook > 'mm:ss:ff' }
                   FUNCTION State(AState: Word): Boolean; { test Status field }
                   FUNCTION Init: Boolean; {Initialise le Cd}
 
         END;
 

:TDate
^Type TDate

 Come From : ~Unit MOS_STR~

 Type TDate=Record                          {*MOS date type*}
        Day,Month:Byte;
        Year:Word;
      End;
:TTime
^Type TTime

 Come From : ~Unit MOS_STR~

      TTime=Record                          {*MOS time type*}
        Hour,Minute,Second,Hund:Byte;
      End;
:TPointer
^Type TPointer

 Come From : ~Unit MOS_STR~

      TPointer = Record                     {*Redefinition of a Pointer*}
                   Case Boolean of
                     TRUE:(Offset,Segment:Word);
                     FALSE:(P:Pointer);
                  End;


:TString1
^Type TString1

 Come From : ~Unit MOS_VAR~

 Type TString1=String[1];                 {*String 1*}
:TClip
^Type TClip

 Come From : ~Unit MOS_VAR~

 Type TClip=Record                        {*Coordinates Clip Window*}
     X1,Y1,X2,Y2:Integer;
     End;
:TColor
^Type TColor

 Come From : ~Unit MOS_VAR~

     TColor=Record                        {*Color Record*}
     R,G,B          :Byte;                {*RGB Values of a color*}
     End;

:TCanvas
^Type TCanvas

 Come From : ~Unit MOS_GAD~

 TCanvas=Record                           {*Canvas Box definition*}
      X:Array[1..MaxTaquets] of Integer;
      Y:Array[1..MaxTaquets] of Integer;  {*Points coordinates*}
      SizeTaq     :Integer;               {*Half size of a Taquet*}
      Status_Size :Boolean;               {*Canvas currently resized*}
      Status_Move :Boolean;               {*Canvas currently moved*}
      MouseBut    :Byte;                  {*Mouse Button to Activate*}
      OnTaquet    :Byte;                  {*Mouse on Taquet number*}
      Color       :Word;                  {*Pen color for the Canvas*}
      Mx,My       :Integer;               {*Mouse Position when click a Taquet*}
      OldX,OldY   :Integer;               {*Previous Mouse Position*}
      Id          :Word;                  {*Bits selection for Canvas*}
      {*Bit 0  $0001 : 1 = Enable Move Canvas*}
      {*Bit 1  $0002 : 1 = Canvas Freezed*}
      {*Bit 2  $0004 : 1 = Unvisible Canvas*}
      {*Bit 3  $0008 : 1 = Draw Canvas box*}
      {*Bit 4  $0010 : 1 = Hand Pointer on Taquets*}
      {*Bit 5  $0020 : 1 = Enable Resize Canvas*}
      {*Bit 6  $0040 : 1 = Inverse Canvas Allowed*}
      {*Bit 7  $0080 : * 1 = Fix black line color*}
      {*Bit 8  $0100 : * 1 = Polygon Mode*}
      {*Bit 8  $0100 : * 1 = Proportional canvas size*}
      IdTaq       :Word;                  {*Bits to Set Taquets (0..8)*}
      End;
:TColorPalette
^Type TColorPalette

 Come From : ~Unit MOS_GAD~

 TColorPalette=Record                     {*Color Palette definition*}
      X1,Y1,X2,Y2 :Integer;               {*Points coordinates*}
      MinC,MaxC   :Longint;               {*Minimum and Maximum Colors Indices*}
      Qtt         :Longint;               {*Quantity of Colors*}
      ColX,LigY   :Integer;               {*Number of Lines and Columns*}
      SizeX,SizeY :Integer;               {*Size of a Cell*}
      MouseBut    :Byte;                  {*Mouse Button to Activate*}
      Mea         :Integer;               {*Half Size between two cells in pixels*}
      Border      :Integer;               {*Border Type*}
      Selected    :Longint;               {*Initial selected color*}
      OcX,OcY     :Integer;               {*Old Cell sensitively activated*}
      Id          :Word;                  {*Bits selection for Gadget*}
      {*Bit 0  $0001 : 1 = Sensitive mouse selection*}
      {*Bit 1  $0002 : 1 = Gadget Freezed*}
      {*Bit 2  $0004 : 1 = Unvisible Gadget*}
      {*Bit 3  $0008 : 1 = Force linear palette*}
      {*Bit 4  $0010 : 1 = Hand Pointer over the Gadget*}
      {*Bit 5  $0020 : 1 = Force square cells*}
      {*Bit 6  $0040 : 1 = Toggle border*}
      {*Bit 7  $0080 : * 1 = Drag and drop to copy color*}
      End;
:TInfoBox
^Type TInfoBox

 Come From : ~Unit MOS_GAD~

 TInfoBox=Record                          {*Info Zone Gadget*}
      X1,Y1,X2,Y2 :Integer;               {*Test mouse coordinates*}
      Xd,Yd,Xf,Yf :Integer;               {*Info box coordinates*}
      Status      :Boolean;               {*Display gadget or no*}
      TempsOk     :Boolean;               {*Elapsed time is 0*}
      Time        :TClock;                {*Pointer to TClock structure*}
      Info        :String;                {*String to display*}
      Swap        :TSwap;                 {*Structure for Refresh Screen*}
      Qtt         :Byte;                  {*Number of info lines*}
      MOx,MOy     :Integer;               {*Old mouse coordinates*}
      Id          :Byte;                  {*Id Pref gadget*}
      End;
:TButton
^Type TButton

 Come From : ~Unit MOS_GAD~

 TButton=Record                           {*Button Gadget*}
      X1,Y1,X2,Y2 :Integer;               {*Button coordinates*}
      TCT         :String;                {*String to display*}
      CoP,CoB     :Byte;                  {*Button color*}
      VanillaKey  :Byte;                  {*Activation key position in string*}
      VaniA       :Byte;                  {*ASCII and Scan code for the Vanillakey*}
      VaniS       :Byte;
      FontType    :String[12];            {*Used font for the Button*}
      FontSize    :Byte;
      ButSp       :Integer;               {*Special button or no*}
      Id          :Word;                  {*Id Pref button*}
      {*Bit 0  $0001 : 1 = Use image palette to display image}
      {*Bit 1  $0002 : 1 = Freezed button*}
      {*Bit 2  $0004 : 1 = Unvisible button*}
      {*Bit 3  $0008 : 1 = Set image in button (ICO, BMP, MGF)*}
      {*Bit 4  $0010 : 1 = Pointer to be Hand over Button*}
      {*Bit 5  $0020 : 1 = Constant Color display*}
      {*Bit 6  $0040 : 1 = Text Shift when selected*}
      {*Bit 7  $0080 : 1 = Repeat Activation (Send TRUE after delay on button)*}
      {*Bit 8  $0100 : 1 = Select button by ENTER key*}
      {*Bit 9  $0200 : 1 = Do not display the box button*}
      {*Bit 10 $0400 : 1 = Text underlined*}
 {- Ne pas utiliser la touche CTRL}
      End;
:TCycler
^Type TCycler

 Come From : ~Unit MOS_GAD~

 TCycler=Record                           {*Cycler Gadget*}
      X1,Y1,X2,Y2 :Integer;               {*Cycler coordinates*}
      TCT         :String;                {*Strings to display*}
      CoP,CoB     :Byte;                  {*Cycler colors*}
      CyclVal     :Integer;               {*Label number currently displayed*}
      FontType    :String[12];            {*Used font for the Cycler*}
      FontSize    :Byte;
      Id          :Word;                  {*Id Prefs cycler*}
      End;
:TSlider
^Type TSlider

 Come From : ~Unit MOS_GAD~

 TSlider=Record                           {*Slider Gadget*}
      X1,Y1,X2,Y2 :Integer;               {*Slider coordinates*}
      Xa,Ya,Xb,Yb :Integer;               {*Slider cursor coordinates*}
      Ox,Oy       :Integer;               {*Old position X & Y cursor*}
      Qtt,Aff     :Longint;               {*Maximum and quantity of items*}
      Typ         :Byte;                  {*Slider type - Right, left, both*}
 {D}     Gdep        :Boolean;               {*Display move buttons*}
      Flg_But     :Boolean;               {*Slider selected*}
      B0,B1       :TButton;               {*Pointer to buttons structures*}
      Psl         :Longint;               {*Actual position of the cursor slider*}
      Id          :Word;                  {*Bits selection for Gadget*}
      {*Bit 0  $0001 : *  1 = Toggle Slider track look*}
      {*Bit 1  $0002 : *  1 = Freezed gadget*}
      {*Bit 2  $0004 : *  1 = Unvisible gadget*}
      {*Bit 3  $0008 : *  1 = Enable full move on one click*}
      {*Bit 4  $0010 : *  1 = Hand pointer over the cursor track*}
      {*Bit 5  $0020 : *  1 = Mode "Full List"*}
      {*Bit 6  $0040 : *  1 = Display Slider track*}
      {*Bit 7  $0080 : *  1 = Display graduations if exists*}
      {*Bit 8  $0100 : *  1 = Display move buttons*}
      {*Bit 9  $0200 : *  1 = Move buttons are on the same side of the track*}
      End;
:TRadioBox
^Type TRadioBox

 Come From : ~Unit MOS_GAD~

 TRadioBox=Record                         {*Radio Box Gadget*}
      X,Y          :Integer;              {*Radio Box coordinates*}
      Style        :Word;                 {*Radio Box style*}
      Color        :Integer;              {*Background color*}
      Status       :Boolean;              {*Status. TRUE=Selected*}
      IDCMP        :Word;                 {*Id Prefs Radio Box*}
      Group        :Byte;                 {*Group number (only for Radio Box)*}
      Cin          :String[50];           {*Attached text to display*}
      PLab         :Byte;                 {*Text position*}
      End;
:TInputText
^Type TInputText

 Come From : ~Unit MOS_GAD~

 TInputText=Record                        {*InputText Gadget*}
      X,Y         :Word;                  {*InputText coordinates*}
      Siz         :Word;                  {*InputText width*}
      Len         :Byte;                  {*Maximum caracters lenght *}
      CoB,Co2     :Byte;                  {*Background colors*}
      Sty         :Byte;                  {*Design styles*}
      Cin         :String;                {*String to display*}
      PM          :TPosMse;               {*Mouse coordinates*}
      Freeze      :Boolean;               {*Freezed gadget or no*}
      FontType    :String[12];            {*Used font for the Button*}
      FontSize    :Byte;
      Id          :Word;                  {*Id Prefs InputText*}
      End;
:TInputSlider
^Type TInputSlider

 Come From : ~Unit MOS_GAD~

 TInputSlider=Record                      {*Input Slider definition*}
      X1,Y1,Sx    :Integer;               {*Gadget position and size*}
      Com         :TInputText;            {*Pointer to an InputText gadget*}
      But1,But2   :TButton;               {*Pointer to 2 Buttons*}
      Min,Max,Step:Longint;               {*Available array and Step*}
      Col1,Col2   :Integer;               {*Colors for Gadget InputText*}
      Style       :Integer;               {*Style for Gadget InputText*}
      Id          :Word;                  {*Bits selection for Canvas*}
      {*Bit 0  $0001 : 1 = Gadget Activated*}
      {*Bit 1  $0002 : 1 = Gadget Freezed*}
      {*Bit 2  $0004 : 1 = Unvisible Gadget*}
      End;
:TVesaMode
^Type TVesaMode

 Come From : ~Unit MOS_VESA~

 Type TVesaMode=Record
        Attr     : Word;         { Mode Attributes                   }
        WinA     : Byte;         { Window A attributes               }
        WinB     : Byte;         { Window B attributes               }
        Gran     : Word;         { Window granularity in K bytes     }
        WinSiz   : Word;         { Size of window in K bytes         }
        SegA     : Word;         { Segment address of window A       }
        SegB     : Word;         { Segment address of window B       }
        WinFunc  : Procedure;    { Windows positioning function      }
        Bytes    : Word;         { Number of bytes per line          }
        Width    : Word;         { Number of horizontal pixels       }
        Height   : Word;         { Number of vertical pixels         }
        CharW    : Byte;         { Width of character cell           }
        CharH    : Byte;         { Height of character cell          }
        Planes   : Byte;         { Number of memory planes           }
        Bits     : Byte;         { Number of bits per pixel          }
        nBanks   : Byte;         { Number of banks        (not used) }
        Model    : Byte;         { Memory model type                 }
        Banks    : Byte;         { Size of bank           (not used) }
        Pages    : Byte;         { Number of image pages             }
        Reserved : Byte; { The following are for 15,16,24,32 bit color modes }
        RedMaskSize   : Byte;    { Size of Red mask in bits          }
        RedFieldPos   : Byte;    { Bit position of LSB of Red mask   }
        GreenMaskSize : Byte;    { Size of Green mask in bits        }
        GreenFieldPos : Byte;    { Bit position of LSB of Green mask }
        BlueMaskSize  : Byte;    { Size of Blue mask in bits         }
        BlueFieldPos  : Byte;    { Bit position of LSB of Blue mask  }
        RsvdMaskSize  : Byte;    { Size of Reserved mask in bits     }
        RsvdFieldPos  : Byte;    { Bit pos. of LSB of Reserved mask  }
        DirColModeInf : Byte;    { Direct Colour mode attributes     }
        Filler   : Array[0..215] Of Byte; { Not used - filler        }
      End;
:TModeList
^Type TModeList

 Come From : ~Unit MOS_VESA~

      TModeList=Array[1..32] Of Word;  { List of VESA mode numbers }
:TVesaInfo
^Type TVesaInfo

 Come From : ~Unit MOS_VESA~

      TVesaInfo=Record            { Contains info on the VESA BIOS Extensions }
        Signature    : Array[1..4] of char;{ Signature - Must be "VESA" }
        Version      : Word;      { VESA Version number              }
        OEMName      : Pchar;     { Pointer to manufacturer name     }
        Capabilities : Longint;   { Capabilities       (Not used)    }
        List         : ^TModeList;{ Pointer to list of VESA modes    }
        TotalMemory  : Word;      { Number of 64k memory blocks on card }
        Filler       : Array[1..238] of Byte;
      End;


:TXMSMovStruct
^Type TXMSMovStruct

 Come From : ~Unit MOS_XMS~

 Type    TXMSMovStruct=Record
         Amount       : Longint;  { 32 bit number of bytes to move}
         SourceHandle : Word;     { Handle of Source Block.       }
         SourceOffset : Longint;  { 32 bit offset to source.      }
         DestHandle   : Word;     { Handle of destination.        }
         DestOffset   : Longint;  { 32 bit offset to destination  }
                                  { If SourceHandle is 0 then SourceOffset}
                                  { Is Interpereted as a SEGMENT:OFFSET   }
                                  { into conventional memory.             }
                                  { The Same applies to DestHandle.       }
         End;
:TXMSTab
^Type TXMSTab

 Come From : ~Unit MOS_XMS~

         TXMSTab=Record
         handle_xms                   : Word;
         taille,indice_Min,indice_Max : longint;
         End;
:TXMSHandle
^Type TXMSHandle

 Come From : ~Unit MOS_XMS~

         TXMSHandle=Word;        { Type XMS Handle }
:TXMSBitmap
^Type TXMSBitmap

 Come From : ~Unit MOS_XMS~

         TXMSBitmap = Record
             xi,yi : Word;
             Qtts  : Byte; {  If Qtts=0,the XMS_GetImage don't succeed  }
             h     : TXMSHandle;
         End;
:TXMSStack
^Type TXMSStack

 Come From : ~Unit MOS_XMS~

         TXMSStack=Record             {*XMS Stack record*}
           P_Stack      : TXMSTab;    {*Pointer on an XMS array*}
           Qtt_Items    : Longint;    {*Number of items*}
           Qtt_MaxItems : Longint;    {*Max number of items*}
         End;

:TWinStack
^Type TWinStack

 Come From : ~Unit MOS_WIN~

 Type TWinStack=Record                    {*Stack and windows layers*}
      X1,Y1,X2,Y2:Integer;                {*Coordinates*}
      End;
:TWindow
^Type TWindow

 Come From : ~Unit MOS_WIN~

     TWindow=Record                       {*Window structure*}
     X1,Y1,X2,Y2  :Integer;               {*Main coordinates*}
     Xa,Ya,Xb,Yb  :Integer;               {*Previous coordinates before move*}
     Xu,Yu,Xv,Yv  :Integer;               {*Second coordinates for extend*}
     XMin,YMin    :Integer;               {*Minimum size of window*}
     XMax,YMax    :Integer;               {*Maximum size of window*}
     Name         :String[60];            {*Window title*}
     Close        :TButton;                  {*Structure Gadget Close Window*}
     Swap         :TButton;                  {*Structure Gadget Swap Window*}
     Extend       :TButton;                  {*Structure Gadget Extend Window*}
     Size         :TButton;                  {*Structure Gadget Size Window*}
 
     IDCMP        :Word;                  {*Flags Id Window*}
            {*Bit 0  $0001 = Activated      1 = Window Activated*}
            {*Bit 1  $0002 = Extended       1 = Enable Extend*}
            {*Bit 2  $0004 = Size           1 = Enable Resize*}
            {*Bit 3  $0008 = Swap           1 = Enable window Swapping*}
            {*Bit 4  $0010 = Close          1 = Enable Close window*}
            {*Bit 5  $0020 = Backdrop       1 = Window always on back*}
            {*Bit 6  $0040 = Block          1 = Window limited on screen*}
            {*Bit 7  $0080 = Title          1 = Display window title*}
            {*Bit 8  $0100 = Border         1 = Display window borders*}
            {*Bit 9  $0200 = Cursor         1 = Mannage window cursor*}
            {*Bit 10 $0400 = Loked          1 = Window status locked*}
            {*Bit 11 $0800 = Sensitive      1 = Active window is mouse over*}
            {*Bit 12 $1000 = Multi-Windows  1 = Modale window*}
            {*Bit 13 $2000 = Transparent    1 = Transparent background*}
            {*Bit 14 $4000 = Move           1 = Enable window deplacement*}
            {*Bit 15 $8000 = Relief         1 = Reliefs borders*}
 
     IDRES        :Word;                  {*Id Flags*}
            {*Bit 0  $0001 = Zoom Window     1 = Zoom window when Open and Close*}
            {*Bit 1  $0002 = Whole Move      1 = Move window cliking on all his surface*}
            {*Bit 2  $0004 = Window Centered 1 = Center window on screen*}
            {*Bit 4  $0010 = Close ESC       1 = Enable ESC key to close window*}
            {*Bit 5  $0020 = Move with RMB   1 = Move window with RMB*}
            {*Bit 6  $0040 = No Pro-Look     1 = Do not display internal box*}
            {*Bit 7  $0080 = Save Palette    1 = Save and restore 256 Color Palette*}
 
 
            {*Bit 12 $1000 = No fade in title*}
            {*Bit 13 $2000 = Wait when window is killed*}
 
     Destroyed    :Boolean;               {*1 =  Window has been destroyed*}
     BarSld       :Integer;               {*Number of sliders*}
     Num          :Byte;                  {*Window number*}
     Coul         :Integer;               {*Window background color*}
     Curs         :TLocate;               {*Structure for cursor*}
     Sw           :TSwap;                 {*Structure for deplacement*}
     Palette      :TPalette256;           {*Save / Restore Palette*}
     MsePointerMode :Byte;
     End;
:TProgress
^Type TProgress

 Come From : ~Unit MOS_REQ~

 Type TProgress=Record                   {*Structure Progression Bar*}
      W    :TWindow;                     {*Pointer to Window structure*}
      B    :TButton;                     {*Pointer to Button "Abort" structure*}
      Abort:Boolean;                     {*Abort Operation*}
      Init :Byte;                        {*Initialise le Requester*}
      End;
:TRecurseProc
^Type TRecurseProc

 Come From : ~Unit MOS_FIL~

 Type  TRecurseProc = Procedure (x:PathStr); {*Type for File_Find*}
:TRSearchRec
^Type TRSearchRec

 Come From : ~Unit MOS_FIL~

       TRSearchRec=Record
        FileName : String[128];   {*Name of the file Found*}
        Dirinfo  : SearchRec;     {*SearchRec of the file *}
       End;
:TCard
^Type TCard

 Come From : ~Unit MOS_CAR~

 Type TCard=Record                       {*Card record*}
     Num                :Byte;           {*Card number (1 to 52)*}
     Value              :Byte;           {*1 to 13 : 1=As, 13=King*}
     Color              :Byte;           {*1=Carreau, 2=Pique, 3=Coeur, 4=TrŠfle*}
     Ident              :String[10];     {*Identificator (Variable)*}
     Px,Py              :Integer;        {*X,Y Position*}
     FName              :String[12];     {*Attached Filename for BMP*}
     Visible            :Boolean;        {*Card is visible ?*}
     Movable            :Boolean;        {*Card is movable*}
     Recto              :Boolean;        {*Side of card to display*}
     End;
:TCards
^Type TCards

 Come From : ~Unit MOS_CAR~

     TCards=Record                       {*Game cards record*}
     Max_Cards          :Integer;        {*52 Cards Max*}
     Verso              :String[12];     {*Verso File to use*}
     Cards              :Array[1..52] of TCard;{*Array of cards*}
     End;

:TStack
^Type TStack

 Come From : ~Unit MOS_MEM~

 Type TStack=Record                {*Stack record*}
        P_Stack      : Pointer;    {*@ of the current item in stack*}
        ItemSize     : Word;       {*Size of 1 item*}
        Qtt_Items    : Word;       {*Number of items*}
        Qtt_MaxItems : Word;       {*Max number of items*}
        Size         : Word;       {*Size in byte of the stack*}
      End;

