@ Procedure and Function [A-L] 
:BSET
%ͻ
%                              Procedure BSET                               
%ͼ

 PROTOTYPE :
 Procedure BSET(Var W:Word; B:Byte);	

 UNIT...: ~Unit MOS_ASM~
 IN.....: W (WORD) = Word Register to manage bits.                         
          B (BYTE) = Bit number to operate (0 to 15).                      
 OUT....: /                                                                
 NB.....: ASM68000 function (Origin).                                      
 EXPLAIN: Set the bit "B" of the "W" variable.                             
 SEE ALSO..: 
    ~BCLR~
    ~BCHG~
    ~BTST~

:BCLR
%ͻ
%                              Procedure BCLR                               
%ͼ

 PROTOTYPE :
 Procedure BCLR(Var W:Word; B:Byte);

 UNIT...: ~Unit MOS_ASM~
 IN.....: W (WORD) = Word Register to manage bits.                         
          B (BYTE) = Bit number to operate (0 to 15).                      
 OUT....: /                                                                
 NB.....: ASM68000 function (Origin).                                      
 EXPLAIN: Clear the bit "B" of the "W" variable.                           
 SEE ALSO..: 
    ~BSET~
    ~BCHG~
    ~BTST~

:BCHG
%ͻ
%                              Procedure BCHG                               
%ͼ

 PROTOTYPE :
 Procedure BCHG(Var W:Word; B:Byte);

 UNIT...: ~Unit MOS_ASM~
 IN.....: W (WORD) = Word Register to manage bits.                         
          B (BYTE) = Bit number to operate (0 to 15).                      
 OUT....: /                                                                
 NB.....: ASM68000 function (Origin).                                      
 EXPLAIN: Swap the bit value of the bit "B" for the "W" variable.          
 SEE ALSO..: 
    ~BCLR~
    ~BSET~
    ~BTST~

:BTST
%ͻ
%                               Function BTST                               
%ͼ

 PROTOTYPE :
 Function BTST (W:Word; B:Byte):Boolean;

 UNIT...: ~Unit MOS_ASM~
 IN.....: W (WORD) = Word Register to manage bits.                         
          B (BYTE) = Bit number to operate (0 to 15).                      
 OUT....: (BOOLEAN) = Bit set if TRUE else FALSE.                          
 NB.....: ASM68000 function (Origin).                                      
 EXPLAIN: Test the bit "B" of the "W" variable.                            
 SEE ALSO..: 
    ~BCLR~
    ~BCHG~
    ~BSET~

:Execute
%ͻ
%                             Procedure Execute                             
%ͼ

 PROTOTYPE :
 Procedure Execute(Path, CmdLine : String;Flg:word);

 UNIT...: ~Unit MOS_ASM~
 IN.....: See also Execute_Base                                            
 OUT....: See also Execute_Base                                            
 EXPLAIN: This procedure is the SAME as Execute_Base.                      
          This procedure is here to allow a "low call" of Execute_Base     
          because MOS_SWAP is a high level Unit.                           
 SEE ALSO..: 
    ~Execute_Base~

:Cold_Reboot
%ͻ
%                           Procedure Cold_Reboot                           
%ͼ

 PROTOTYPE :
 Procedure Cold_Reboot;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Make a Cold Reboot.                                              
 NB.....: Be careful, you will lost all your work                          
 SEE ALSO..: 
    ~Warm_Reboot~

:Get_ProcessorType
%ͻ
%                        Function Get_ProcessorType                         
%ͼ

 PROTOTYPE :
 Function Get_ProcessorType:Byte;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: (BYTE) = Processor number.                                       
            0 = 8088                                                       
            1 = 8086                                                       
            2 =  v20                                                       
            3 =  v30                                                       
            4 =  188                                                       
            5 =  186                                                       
            6 =  286                                                       
            7 =  386                                                       
            8 =  486                                                       
 EXPLAIN: Return a number according to the Processor list numbers.         

:Get_CoProcessorType
%ͻ
%                       Function Get_CoProcessorType                        
%ͼ

 PROTOTYPE :
 Function Get_CoProcessorType:Byte;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: (BYTE) = Co-processor number.                                    
            0 =  None                                                      
            1 =  8087                                                      
            2 =  80287                                                     
            3 =  80387                                                     
 EXPLAIN: Return a number according to the coprocessor list numbers.       

:Get_CPUSpeed
%ͻ
%                           Function Get_CPUSpeed                           
%ͼ

 PROTOTYPE :
 Function Get_CPUSpeed:String;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: (STRING) = String witch contain the value of the speed.          
 EXPLAIN: Return the speed of CPU by a string.                             
 NB.....: The values founds are about + ou - 10%                           

:Get_WinVersion
%ͻ
%                          Function Get_WinVersion                          
%ͼ

 PROTOTYPE :
 Function Get_WinVersion:String;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: (STRING) = N of version of Windows.                             
 EXPLAIN: Return the N of version of Windows.                             
 NB.....: Windows must be loaded to call this function.                    
          Works only for Windows versions > 2.0.                           

:Get_DOSVersion
%ͻ
%                          Function Get_DOSVersion                          
%ͼ

 PROTOTYPE :
 Function Get_DOSVersion:String;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: (STRING) = Version and Revision of the Version.                  
 EXPLAIN: Return the N of the DOS version.                                

:FillWord
%ͻ
%                            Procedure FillWord                             
%ͼ

 PROTOTYPE :
 Procedure FillWord(Var X; Count : Word; Value : Word);

 UNIT...: ~Unit MOS_ASM~
 IN.....: X (UNTYPED) = Variable to fill                                   
          Count (WORD) = How many time you want to make the copy           
          Value (WORD) = Value to fill X.                                  
 OUT....: X (UNTYPED).                                                     
 EXPLAIN: Same as FillChar but with Words.                                 
          Count = Number of byte of X variable / 2                         
 EXAMPLE: S:String[79];                                                    
          FillWord(S,40,0);                                                

:Exg
%ͻ
%                               Procedure Exg                               
%ͼ

 PROTOTYPE :
 Procedure Exg(Var A,B:Integer);

 UNIT...: ~Unit MOS_ASM~
 IN.....: A,B (INTEGER): The 2 interger variables to exchange.             
 OUT....: A,B (INTEGER): The 2 interger variables exchanged.               
 EXPLAIN: Exchange the contain of the 2 integer.                           

:Beep
%ͻ
%                              Procedure Beep                               
%ͼ

 PROTOTYPE :
 Procedure Beep;

 UNIT...: ~Unit MOS_ASM~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Produce a sound modulation.                                      
 EXAMPLE: Beep;                                                            

:Comp_Blocks
%ͻ
%                           Function Comp_Blocks                            
%ͼ

 PROTOTYPE :
 Function Comp_Blocks(Buf1,Buf2:Pointer;BufSize:Word):Boolean;

 UNIT...: ~Unit MOS_ASM~
 IN.....: Buf1,Buf2 (POINTER) = Address of the 2 blocks in memory to       
                                compare.                                   
          Bufsize (WORD) = Size of the buffers                             
 OUT....: (BOOLEAN) = TRUE if the blocks are equals, else FALSE.           
 EXPLAIN: Test 2 blocks of memory if they are the sames.                   

:Combo
%ͻ
%                              Procedure Combo                              
%ͼ

 PROTOTYPE :
 Procedure Combo(X1,Y1,Sx:Integer; Col1,Col2,Col3,Id,Selected:Word; Var C:
           TCombo);

 UNIT...: ~Unit MOS_OCG~
 IN.....: X1,Y1 (INTEGER) = Gadget coordinates.                            
          Sx (INTEGER) = Gadget width.                                     
          Col1,Col2,Col3 (INTEGER) = Gadgets colors.                       
          Id (WORD) = Bits to parameter gadget :                           
             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 item                             
          Selected (WORD) = Define selected item.                          
             If 0 then no item selected.                                   
          C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 NB.....: Maximum Combo list is limited to 500 items.                      
 EXPLAIN: Build and display a Combo Gadget.                                

:Combo_Init
%ͻ
%                           Procedure Combo_Init                            
%ͼ

 PROTOTYPE :
 Procedure Combo_Init(Var C:TCombo);

 UNIT...: ~Unit MOS_OCG~
 IN.....: C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 EXPLAIN: Initialise the Combo Gadget.                                     
          This procedure must be called before every others Combo procs.   

:Combo_Kill
%ͻ
%                           Procedure Combo_Kill                            
%ͼ

 PROTOTYPE :
 Procedure Combo_Kill(C:TCombo);

 UNIT...: ~Unit MOS_OCG~
 IN.....: C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 EXPLAIN: Kill the Combo Gadget structure.                                 
          This procedure must be called at the end of the Combo management.

:Combo_Clear
%ͻ
%                           Procedure Combo_Clear                           
%ͼ

 PROTOTYPE :
 Procedure Combo_Clear(C:TCombo);

 UNIT...: ~Unit MOS_OCG~
 IN.....: C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 EXPLAIN: Clear all the fields in the Combo Gadget.                        

:Combo_AddItem
%ͻ
%                          Function Combo_AddItem                           
%ͼ

 PROTOTYPE :
 Function Combo_AddItem(Item:String; C:TCombo):Boolean;

 UNIT...: ~Unit MOS_OCG~
 IN.....: Item (STRING) = String to add to the Combo list.                 
          C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 EXPLAIN: Add a string item to a Combo Gadget.                             

:Combo_GetItem
%ͻ
%                          Function Combo_GetItem                           
%ͼ

 PROTOTYPE :
 Function Combo_GetItem(Item:Integer; C:TCombo):String;

 UNIT...: ~Unit MOS_OCG~
 IN.....: Item (INTEGER) = Item number in Combo list.                      
          C (TCombo) = Pointer to a Combo structure.                       
 OUT....: (STRING) = Return the string item.                               
 EXPLAIN: Get the string of a Combo item.                                  

:Combo_Draw
%ͻ
%                           Procedure Combo_Draw                            
%ͼ

 PROTOTYPE :
 Procedure Combo_Draw(Var C:TCombo);

 UNIT...: ~Unit MOS_OCG~
 IN.....: C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 EXPLAIN: Redraw the Combo Gadget.                                         

:Combo_Freeze
%ͻ
%                          Procedure Combo_Freeze                           
%ͼ

 PROTOTYPE :
 Procedure Combo_Freeze(Status:Boolean; Var C:TCombo);

 UNIT...: ~Unit MOS_OCG~
 IN.....: Status (BOOLEAN) = On = Freeze the Gadget.                       
          C (TCombo) = Pointer to a Combo structure.                       
 OUT....: /                                                                
 EXPLAIN: Freeze or Unfreeze the Combo Gadget.                             

:Combo_GetMsg
%ͻ
%                           Function Combo_GetMsg                           
%ͼ

 PROTOTYPE :
 Function Combo_GetMsg(Var C:TCombo):Integer;

 UNIT...: ~Unit MOS_OCG~
 IN.....: C (TCombo) = Pointer to a Combo structure.                       
 OUT....: (INTEGER) = Selected item number.                                
          Use "Combo_GetItem" to get the item string.                      
 EXPLAIN: Get messages from the Combo gadget.                              

:Execute_Blanker
%ͻ
%                         Procedure Execute_Blanker                         
%ͼ

 PROTOTYPE :
 Procedure Execute_Blanker(Blanker:String; Module:Byte);

 UNIT...: ~Unit MOS_BLK~
 IN.....: Blanker (STRING) = Filename for the blanker.                     
          Module (BYTE) = A byte to specify execution or parameter.        
                 BLK_Execute   : Execute Blanker                           
                 BLK_Parameter : Parameter Blanker                         
 OUT....: /                                                                
 EXPLAIN: Execute an external screen blanker.                              
 NB.....: The blanker must be in the "SYSTEM\BLANKERS" directory.          

:Get_BMPInfo
%ͻ
%                           Procedure Get_BMPInfo                           
%ͼ

 PROTOTYPE :
 Procedure Get_BMPInfo(NameFile:String;Var ScreenX,ScreenY:word;var Colors:
           longint);

 UNIT...: ~Unit MOS_BMP~
 IN.....: NameFile : (STRING) = Path + Name of the file to test            
 OUT....: ScreenX : (WORD) = Horizontal Size in pixel                      
          ScreenY : (WORD) = Vertical Size in pixel                        
          Colors : (LONGINT) = Number of colors in bmp file.               
 EXPLAIN: Get information about a bmp file.                                
          If file is not a BMP file, the 3 parameters = 0.                 

:Create_BMP
%ͻ
%                           Procedure Create_BMP                            
%ͼ

 PROTOTYPE :
 Procedure Create_BMP(FileName:String;x1,y1,x2,y2:Integer);

 UNIT...: ~Unit MOS_BMP~
 IN.....: FileName : (STRING) = Path + Name of a file to save.             
          X1,Y1,X2,Y2 : (INTEGER) = Box where to get pixel to save.        
 OUT....: /                                                                
 EXPLAIN: Create or overwrite a BMP file.Make a "snapshot" of the screen.  
          This Procedure save a screen or a part of screen to a file.      
 BUGS...: Parameters X1,Y1,X2,Y2 must be correct.                          
 EXAMPLE: CREATE_BMP('Image1.bmp',0,0,VESA_GetMaxX,VESA_GetMaxY)           

:KeyPressed
%ͻ
%                            Function KeyPressed                            
%ͼ

 PROTOTYPE :
 Function KeyPressed: Boolean;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if a key is pressed on the keyboard             
 EXPLAIN: Determines if a key has been pressed on the keyboard.            
 CF.....: Tp7 CRT Unit.                                                    

:GotoXY
%ͻ
%                             Procedure GotoXY                              
%ͼ

 PROTOTYPE :
 Procedure GotoXY(X,Y: Byte);

 UNIT...: ~Unit MOS_CRT~
 IN.....: X,Y (BYTE)                                                       
 OUT....: /                                                                
 EXPLAIN: Moves the cursor to the given coordinates within the virtual     
          screen.                                                          
 CF.....: Tp7 CRT Unit.                                                    

:ClrScr
%ͻ
%                             Procedure ClrScr                              
%ͼ

 PROTOTYPE :
 Procedure ClrScr;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Clears the active windows and returns the cursor to the upper-   
          left-corner.                                                     
 CF.....: Tp7 CRT Unit.                                                    

:ClrEol
%ͻ
%                             Procedure ClrEol                              
%ͼ

 PROTOTYPE :
 Procedure ClrEol;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Clears all characters from the cursor position to the end of the 
          line without moving the cursor.                                  
 CF.....: Tp7 CRT Unit.                                                    

:InsLine
%ͻ
%                             Procedure InsLine                             
%ͼ

 PROTOTYPE :
 Procedure InsLine;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Inserts an empty line at the cursor position.                    
 CF.....: Tp7 CRT Unit.                                                    

:DelLine
%ͻ
%                             Procedure DelLine                             
%ͼ

 PROTOTYPE :
 Procedure DelLine;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Deletes the line containing the cursor.                          
 CF.....: Tp7 CRT Unit.                                                    

:LowVideo
%ͻ
%                            Procedure LowVideo                             
%ͼ

 PROTOTYPE :
 Procedure LowVideo;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Selects low intensity characters.                                
 CF.....: Tp7 CRT Unit.                                                    

:HighVideo
%ͻ
%                            Procedure HighVideo                            
%ͼ

 PROTOTYPE :
 Procedure HighVideo;

 UNIT...: ~Unit MOS_CRT~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Selects high-intensity characters.                               
 CF.....: Tp7 CRT Unit.                                                    

:Delay
%ͻ
%                              Procedure Delay                              
%ͼ

 PROTOTYPE :
 Procedure Delay (MS : Word);

 UNIT...: ~Unit MOS_CRT~
 IN.....: MS (WORD) = specifies the number of milliseconds to wait.        
 OUT....: /                                                                
 EXPLAIN: Delays a specified number of milliseconds.                       
 CF.....: Tp7 CRT Unit.                                                    

:AssignCrt
%ͻ
%                            Procedure AssignCrt                            
%ͼ

 PROTOTYPE :
 Procedure AssignCrt(var F: Text);

 UNIT...: ~Unit MOS_CRT~
 IN.....: F (TEXT) =                                                       
 OUT....: F (TEXT) =                                                       
 EXPLAIN: Associates a text file with the CRT window.                      
 CF.....: Tp7 CRT Unit.                                                    

:Dsk_TestIOCTL
%ͻ
%                          Function Dsk_TestIOCTL                           
%ͼ

 PROTOTYPE :
 Function Dsk_TestIOCTL(var F:text):Boolean;

 UNIT...: ~Unit MOS_CRT~
 IN.....: F (TEXT) = OutPut or InPut.                                      
 OUT....: (BOOLEAN) = FALSE if command line parameter is set               
 EXPLAIN: Dsk_TestIOCTL(OutPut) = FALSE if >File or >>File is on command   
                               line parameter else TRUE.                   
          Dsk_TestIOCTL(InPut) = FALSE if <File is on command line         
                               parameter else TRUE.                        
 EXAMPLE: Dsk_TestIOCTL(Input) or Dsk_TestIOCTL(Output)                    

:Init_Debug
%ͻ
%                           Procedure Init_Debug                            
%ͼ

 PROTOTYPE :
 Procedure Init_Debug;

 UNIT...: ~Unit MOS_DEB~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Store informations for debugging.                                
          Must be set at the begining of the program.                      
 SEE ALSO..: 
    ~Done_Debug~

:Done_Debug
%ͻ
%                           Procedure Done_Debug                            
%ͼ

 PROTOTYPE :
 Procedure Done_Debug;

 UNIT...: ~Unit MOS_DEB~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Show miscellaneous information about memory and disk.            
          Must be set at the end of the program.                           
 SEE ALSO..: 
    ~Init_Debug~

:Gad_DiskFile
%ͻ
%                           Function Gad_DiskFile                           
%ͼ

 PROTOTYPE :
 Function Gad_DiskFile(X1,Y1,X2,Y2:Integer; Id:Word; Location:String):String;

 UNIT...: ~Unit MOS_DIR~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Box coordinates.                         
          Id (WORD) = Bit to parameter.                                    
          Location (STRING) = Path + filename to scan.                     
 OUT....: (STRING) = Return path and file name of the selected file.       
 EXPLAIN: Display in a list the specified path and files, and allow you    
          to navigate in disks.                                            
 EXAMPLE: Gad_DiskFile(100,50,300,150,$0000,'C:\DOS\EDIT.COM');            




:Get_GIFInfo
%ͻ
%                           Procedure Get_GIFInfo                           
%ͼ

 PROTOTYPE :
 Procedure Get_GIFInfo(NameFile:String;Var ScreenX,ScreenY,Colors:Word);

 UNIT...: ~Unit MOS_GFX~
 IN.....: NameFile (STRING) = Path + Name of the GIF file to get infos.    
 OUT....: ScreenX (WORD) = Horizontal Size (Width) of the GIF file.        
          ScreenY (WORD) = Vertical Size (Heigth) of the GIF file.         
          Colors  (WORD) = Number of colors in the palette.                
 EXPLAIN: Get informations on a GIF File.                                  
 OPT....: Perharps.                                                        
 SEE ALSO..: 
    ~Test_Gif~

:Get_Palette256
%ͻ
%                         Procedure Get_Palette256                          
%ͼ

 PROTOTYPE :
 Procedure Get_Palette256 (Var Pal : TPalette256);

 UNIT...: ~Unit MOS_GPH~
 IN.....: /                                                                
 OUT....: Pal (TPALETTE256) = Array of colors.                             
 EXPLAIN: Get the 256 RGB values of the palette of a 256 color mode.       

:Conv_Dos2Mode
%ͻ
%                          Function Conv_Dos2Mode                           
%ͼ

 PROTOTYPE :
 Function Conv_Dos2Mode(Mode:Word):Byte;

 UNIT...: ~Unit MOS_GPH~
 IN.....: Mode : (WORD) = Vesa video mode (C.f. VESA_SetMode)              
 OUT....: (BYTE) = Mos video mode.                                         
 EXPLAIN: Convert a mode number (from Dos) to a Mos mode number.           
          If Mode is incorrect, then return $FF.                           
 SEE ALSO..: 
    ~VESA_SetMode~

:Conv_Mode2Dos
%ͻ
%                          Function Conv_Mode2Dos                           
%ͼ

 PROTOTYPE :
 Function Conv_Mode2Dos(Mode:Byte):Word;

 UNIT...: ~Unit MOS_GPH~
 IN.....: Mode : (BYTE) = Mos video mode (C.f. VESA_Initgraph mode)        
 OUT....: (WORD) = Dos video mode.                                         
 EXPLAIN: Convert a mode number (from Mos) to a Dos mode number.           
          If Mode is incorrect, then return $FFFF.                         
 SEE ALSO..: 
    ~VESA_Initgraph~


:Kbd_InitCursor
%ͻ
%                         Procedure Kbd_InitCursor                          
%ͼ

 PROTOTYPE :
 Procedure Kbd_InitCursor(Style,Blink:Integer; Var Loc:TLocate);

 UNIT...: ~Unit MOS_KBD~
 IN.....: Style (INTEGER) = Cursor style :                                 
               1 = Plain                                                   
               2 = Underline                                               
               3 = Vertical                                                
          Blink (INTEGER) = Blink speed (1/100 sec).                       
          Loc (TLocate) = Pointer to a cursor structure.                      
 OUT....: /                                                                
 EXPLAIN: Define prefs for the graphic cursor                              
 EXAMPLE: Kbd_InitCursor(1,20,Loc);                                        

:Kbd_Locate
%ͻ
%                           Procedure Kbd_Locate                            
%ͼ

 PROTOTYPE :
 Procedure Kbd_Locate(X,Y:Integer; Var Loc:TLocate);

 UNIT...: ~Unit MOS_KBD~
 IN.....: X,Y (INTEGER) = X,Y position of the graphic cursor.              
          Loc (TLocate) = Pointer to a cursor structure.                      
 OUT....: /                                                                
 EXPLAIN: Set the graphic cursor to the X,Y screen position (Pixels).      
 EXAMPLE: Kbd_Locate(50,20,Loc);                                           

:Kbd_CursorOn
%ͻ
%                          Procedure Kbd_CursorOn                           
%ͼ

 PROTOTYPE :
 Procedure Kbd_CursorOn(Var Loc:TLocate);

 UNIT...: ~Unit MOS_KBD~
 IN.....: Loc (TLocate) = Pointer to a cursor structure.                      
 OUT....: /                                                                
 EXPLAIN: Display graphic cursor.                                          

:Kbd_CursorOff
%ͻ
%                          Procedure Kbd_CursorOff                          
%ͼ

 PROTOTYPE :
 Procedure Kbd_CursorOff(Var Loc:TLocate);

 UNIT...: ~Unit MOS_KBD~
 IN.....: Loc (TLocate) = Pointer to a cursor structure.                      
 OUT....: /                                                                
 EXPLAIN: Hide graphic cursor.                                             

:Kbd_TestKey
%ͻ
%                           Function Kbd_TestKey                            
%ͼ

 PROTOTYPE :
 Function Kbd_TestKey(Ac,Sc:Byte):Boolean;

 UNIT...: ~Unit MOS_KBD~
 IN.....: Ac,Sc (BYTE) = ASCII Code and SCAN Code for the key.             
 OUT....: (BOOLEAN) = TRUE = Key pressed.                                  
 EXPLAIN: Test a known keyboard key.                                       
          This function must be used everytime you want to test a key.     
 EXAMPLE: If Kbd_TestKey(0,72) Then Write('Key Up pressed...');            
 SEE ALSO..: 
    ~Kbd_GetChar~
    ~Kbd_TestChar~

:Kbd_TestChar
%ͻ
%                           Function Kbd_TestChar                           
%ͼ

 PROTOTYPE :
 Function Kbd_TestChar(Ac,Sc:Byte):Boolean;

 UNIT...: ~Unit MOS_KBD~
 IN.....: Ac (BYTE) = ASCII character                                      
          Sc (BYTE) = Scan Code                                            
 OUT....: (BOOLEAN) = Wanted key pressed.                                  
 EXPLAIN: Test a key without waiting on the function.                      
          This function do not clear the key from the keyboard buffer.     
 EXAMPLE: If Kbd_TestChar(0,59) Then Begin Readkey; Readkey; End;          
 NB.....: This function usualy don't be called. For a clean code, you      
          must use the Kbd_TestKey function.                               
          To determine the key values, use this program :                  
             Writeln(ord(readkey));                                        
             Writeln(ord(readkey));                                        
          F1         : 0,59                                                
          F10        : 0,68                                                
          ALT   + F1 : 0,104                                               
          CTRL  + F1 : 0,94                                                
          SHIFT + F1 : 0,84                                                
          DOWN ARROW : 0,80                                                
 SEE ALSO..: 
    ~Kbd_GetChar~
    ~Kbd_TestKey~

:Kbd_GetChar
%ͻ
%                           Function Kbd_GetChar                            
%ͼ

 PROTOTYPE :
 Function Kbd_GetChar(Var Ac,Sc:Byte):Boolean;

 UNIT...: ~Unit MOS_KBD~
 IN.....: Ac,Sc (BYTE) = ASCII Code and SCAN Code for the key.             
 OUT....: (BOOLEAN) = A key has been pressed.                              
          Return Ac,Sc (BYTE) = ASCII and Scan Code for the pressed key.   
 EXPLAIN: Test if a key is pressed, and return his code.                   
 EXAMPLE: If Kbd_GetChar(Ac,Sc) Then Write(Chr(As));                       
 SEE ALSO..: 
    ~Kbd_TestKey~
    ~Kbd_TestChar~

:Kbd_TestSpecialKey
%ͻ
%                        Function Kbd_TestSpecialKey                        
%ͼ

 PROTOTYPE :
 Function Kbd_TestSpecialKey(Num,Mode:Byte):Boolean;

 UNIT...: ~Unit MOS_KBD~
 IN.....: Num (BYTE) = Id number(s) of the special key(s) to test.         
          Bit Num     Utilisation                                          
           0  $01   Right shift key pressed                                
           1  $02   Left  shift key pressed                                
           2  $04   Ctrl        key pressed                                
           3  $08   Alt         key pressed                                
           4  $10   Scroll Lock active                                     
           5  $20   Num Lock    active                                     
           6  $40   Caps Lock   active                                     
           7  $80   Insert state activated                                 
          Mode (BYTE) = Test Mode for multiple combinaison of keys         
           B_AND = 0 : If more than 1 key is specified in Num, this        
                     function return TRUE only if all the keys are pressed 
                     in the same time.                                     
           B_OR = 1 : If more than 1 key is specified in Num, this function
                    return TRUE only if one of the keys are pressed.       
 OUT....: (BOOLEAN) = TRUE = A key is pressed.                             
 EXPLAIN: Test if some special(s) key(s) are activated.                    
          If you want to test if CTRL key is pressed, use parameter $4 for 
          Num, and you have the answer.                                    
          Num is a bit mask, you can have test several                     
          combinaisons of keys at the same time (Mode=0), or if you want   
          to test one of those keys.                                       
 EXAMPLE: If Kbd_TestSpecialKey($1,B_AND) Then Write('R Shift Pressed');   
          If Kbd_TestSpecialKey($3,B_AND) Then Write('R and L Shift Pressed');
          If Kbd_TestSpecialKey($1,B_OR) Then Write('R Shift Pressed');    
          If Kbd_TestSpecialKey($3,B_OR) Then Write('R Or L Shift Pressed');
 OPT....: Could be coded 100% in Asm.                                      

:Kbd_KeyPressedNow
%ͻ
%                        Function Kbd_KeyPressedNow                         
%ͼ

 PROTOTYPE :
 Function Kbd_KeyPressedNow:Boolean;

 UNIT...: ~Unit MOS_KBD~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE  = A key is pressed now.                        
                      FALSE = No keys are pressed now.                     
 EXPLAIN: This function allow you to know if a key is pressed at the moment
          This function don't look in the keyboard buffer to see if a      
          key has been pressed. Keyboard buffer don't be flushed.          
 NB.....: All the keys are checked include (CTRL, NUM LOCK, SHIFT...)      

:Kbd_SetSpeedKey
%ͻ
%                         Procedure Kbd_SetSpeedKey                         
%ͼ

 PROTOTYPE :
 Procedure Kbd_SetSpeedKey(Rate,Delay:Byte);

 UNIT...: ~Unit MOS_KBD~
 IN.....: Rate, Delay (BYTE) = Speed and delay for keyboard.               
 OUT....: /                                                                
 EXPLAIN: Set the keyboard speed and delay as the DOS function             
          "MODE CON RATE=X DELAY=Y".                                       

:Kbd_TextCursorOn
%ͻ
%                        Procedure Kbd_TextCursorOn                         
%ͼ

 PROTOTYPE :
 Procedure Kbd_TextCursorOn;

 UNIT...: ~Unit MOS_KBD~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Text cursor displayed.                                           
 SEE ALSO..: 
    ~Kbd_TextCursorOff~

:Kbd_TextCursorOff
%ͻ
%                        Procedure Kbd_TextCursorOff                        
%ͼ

 PROTOTYPE :
 Procedure Kbd_TextCursorOff;

 UNIT...: ~Unit MOS_KBD~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Text cursor hidden.                                              
 SEE ALSO..: 
    ~Kbd_TextCursorOn~

:Kbd_SetTextCursor
%ͻ
%                        Procedure Kbd_SetTextCursor                        
%ͼ

 PROTOTYPE :
 Procedure Kbd_SetTextCursor;

 UNIT...: ~Unit MOS_KBD~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Set the cursor in text mode.                                     
 SEE ALSO..: 
    ~Kbd_TextCursorOn~
    ~Kbd_TextCursorOff~

:Kbd_PurgeBuffer
%ͻ
%                         Procedure Kbd_PurgeBuffer                         
%ͼ

 PROTOTYPE :
 Procedure Kbd_PurgeBuffer;

 UNIT...: ~Unit MOS_KBD~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Clear the keyboard buffer.                                       
 EXAMPLE: Kbd_PurgeBuffer.                                                 

:Kbd_TestExtended
%ͻ
%                         Function Kbd_TestExtended                         
%ͼ

 PROTOTYPE :
 Function Kbd_TestExtended:Boolean;

 UNIT...: ~Unit MOS_KBD~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE = Extended keyboard.                            
 EXPLAIN: Return TRUE if the keyboard is extended.                         

:Kbd_GetASCIICode
%ͻ
%                         Function Kbd_GetASCIICode                         
%ͼ

 PROTOTYPE :
 Function Kbd_GetASCIICode(V:Byte):Byte;

 UNIT...: ~Unit MOS_KBD~
 IN.....: Val (BYTE) = SCAN code value.                                    
 OUT....: (BYTE) = ASCII code value.                                       
 EXPLAIN: Return the ASCII code of a key (255 if error).                   
 EXAMPLE: R:=Kbd_GetASCIICode(37);                                         

:Kbd_GetScanCode
%ͻ
%                         Function Kbd_GetScanCode                          
%ͼ

 PROTOTYPE :
 Function Kbd_GetScanCode(V:Byte):Byte;

 UNIT...: ~Unit MOS_KBD~
 IN.....: Val (BYTE) = ASCII code value.                                   
 OUT....: (BYTE) = SCAN code value.                                        
 EXPLAIN: Return the SCAN code of a key (0 if error).                      
 EXAMPLE: R:=Kbd_GetScanCode(65);                                          

:List_Define
%ͻ
%                           Function List_Define                            
%ͼ

 PROTOTYPE :
 Function List_Define (Var L:TList; Title:String; Separator:Char;X1,Y1,X2,Y2:
          Integer;Qtt:Longint; Color,Color2,Id:Word):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Title (String) = List title(s).                                  
          Separator (Char) = List column char separator.                   
          X1,Y1,X2,Y2 (Integer) = Box-List position and size definition.   
          Qtt (Longint) = Maximum quantity of Items managed by the list.   
          Color (Word) = Background color for the list.                    
          Color2 (Word) = Second background color for the list.            
          Id (Word) = Bits definition for the list.                        
              See also the TList structure.                                
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Define parameters for the list.                                  
 SEE ALSO..: 
    ~List_Redefine~
    ~List_SetId~
    ~TList~

:List_ReDefine
%ͻ
%                          Procedure List_ReDefine                          
%ͼ

 PROTOTYPE :
 Procedure List_ReDefine (Var L:TList; X1,Y1,X2,Y2:Integer; Color,Color2,Id:
           Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          X1,Y1,X2,Y2 (Integer) = Box-List position and size definition.   
          Color (Word) = Background color for the list.                    
          Color2 (Word) = Second background color for the list.            
          Id (Word) = Bits definition for the list.                        
 OUT....: /                                                                
 EXPLAIN: Modify the List parameters.                                      
 NB.....: You dont need to use a "List_Kill" before using this function.   
 SEE ALSO..: 
    ~List_Define~

:List_Kill
%ͻ
%                            Procedure List_Kill                            
%ͼ

 PROTOTYPE :
 Procedure List_Kill (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Kill the XMS array allocated for the List.                       
          By extention, kill the List.                                     

:List_Test
%ͻ
%                            Function List_Test                             
%ͼ

 PROTOTYPE :
 Function List_Test (Var L:TList):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: Resultat (Longint) = Get the selected Item number.               
              Return 0  if nothing happen.                                 
              Return -1 if a F5 is pressed.                                
              Return -2 if a CTRL A is pressed.                            
              Return -3 if a CTRL Q is pressed.                            
 EXPLAIN: Test and manage the List, selection, columns and all the list.   
 SEE ALSO..: 
    ~List_TestKeys~
    ~List_TestSizeCol~
    ~List_TestMoveCol~
    ~List_TestSortList~

:List_Save
%ͻ
%                            Function List_Save                             
%ͼ

 PROTOTYPE :
 Function List_Save ( L:TList; FName:String):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          FName (String) = Path + Filename to save datas.                  
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Save the datas List in a file.                                   
 SEE ALSO..: 
    ~List_Load~

:List_Load
%ͻ
%                            Function List_Load                             
%ͼ

 PROTOTYPE :
 Function List_Load (Var L:TList; FName:String):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          FName (String) = Path + Filename to load datas.                  
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Load the List in memory from a file.                             
 SEE ALSO..: 
    ~List_Save~

:List_Clear
%ͻ
%                           Procedure List_Clear                            
%ͼ

 PROTOTYPE :
 Procedure List_Clear (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Clear the list in memory (All the field's Items).                

:List_Sort
%ͻ
%                            Procedure List_Sort                            
%ͼ

 PROTOTYPE :
 Procedure List_Sort (Var L:TList; Column,Sens:Byte);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Byte) = A column number.                                 
          Sens (Byte) = (Sort_AZ) 0 = Alphabetical order.                  
                        (Sort_ZA) 1 = Reverse order.                       
 OUT....: /                                                                
 EXPLAIN: Sort the list in alphabetical or reverse order                   
          using a column to sort.                                          
 SEE ALSO..: 
    ~List_SetSortInfo~

:List_Merge
%ͻ
%                            Function List_Merge                            
%ͼ

 PROTOTYPE :
 Function List_Merge ( List1,List2:TList; Var LTarget:TList):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List1 (TList) = Pointer to the list structure source 1.          
          List2 (TList) = Pointer to the list structure source 2.          
          LTarget (TList) = Pointer to the destination list.               
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 NB.....: The destination list must be created before using this function  
          by the "List_Define".                                            
 EXPLAIN: Merge two sources Lists in one target List.                      

:List_Copy
%ͻ
%                            Function List_Copy                             
%ͼ

 PROTOTYPE :
 Function List_Copy ( LSource:TList; Var LTarget:TList; Indice:Longint):
          Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: LSource (TList) = Pointer to the source list structure.          
          LTarget (TList) = Pointer to the destination list structure.     
          Indice (Longint) = The Item number in the List.                  
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 NB.....: The destination list must be created before using this function  
          by the "List_Define".                                            
 EXPLAIN: Copy a source List on a destination List.                        

:List_SwapColumns
%ͻ
%                         Function List_SwapColumns                         
%ͼ

 PROTOTYPE :
 Function List_SwapColumns (Var L:TList; Col1,Col2:Byte):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Col1,Col2 (Byte) = Number of the columns to swap.                
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Swap two columns in the list.                                    
 NB.....: Columns attributes are swapped too.                              

:List_AddItem
%ͻ
%                           Function List_AddItem                           
%ͼ

 PROTOTYPE :
 Function List_AddItem (Var L:TList; Phrase:String; Position:Byte):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Phrase (String) = Item string.                                   
          Position (Byte) = Addition type for the Item.                    
            (Insert_First)  0 = Insert item at the first place.            
            (Insert_Append) 1 = Insert item at the end of the list.        
            (Insert_SortAZ) 2 = Insert by alphabetical order.              
            (Insert_SortZA) 3 = Insert by reverse order.                   
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Add an Item to the list.                                         
 NB.....: Default: Others fields of the item are set to 0.                 
 SEE ALSO..: 
    ~List_DeleteItem~

:List_DeleteItem
%ͻ
%                         Function List_DeleteItem                          
%ͼ

 PROTOTYPE :
 Function List_DeleteItem (Var L:TList; Indice:Longint):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Delete an Item from the list.                                    
 SEE ALSO..: 
    ~List_AddItem~

:List_MoveItems
%ͻ
%                          Function List_MoveItems                          
%ͼ

 PROTOTYPE :
 Function List_MoveItems (Var L:TList; Debut,Quantite,NewPos:Longint):Boolean
          ;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Debut (Longint) = Begining of the block.                         
          Quantite (Longint) = Quantity of items in the block.             
          NewPos (Longint) = New position for the block.                   
 OUT....: (Boolean) = TRUE if Ok, else FALSE if an error occured.          
 EXPLAIN: Move a block of Items in the list.                               

:List_TagItem
%ͻ
%                          Procedure List_TagItem                           
%ͼ

 PROTOTYPE :
 Procedure List_TagItem (Var L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 EXPLAIN: Tag one item in the list.                                        
 SEE ALSO..: 
    ~List_UnTagItem~
    ~List_ToggleItem~

:List_UnTagItem
%ͻ
%                         Procedure List_UnTagItem                          
%ͼ

 PROTOTYPE :
 Procedure List_UnTagItem (Var L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 EXPLAIN: Untag an Item in the list.                                       
 SEE ALSO..: 
    ~List_TagItem~
    ~List_ToggleItem~

:List_ToggleItem
%ͻ
%                         Procedure List_ToggleItem                         
%ͼ

 PROTOTYPE :
 Procedure List_ToggleItem (Var L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 EXPLAIN: Toggle the tag of and Item in the list (Tag / Untag).            
 SEE ALSO..: 
    ~List_TagItem~
    ~List_UnTagItem~

:List_TagAllItems
%ͻ
%                        Procedure List_TagAllItems                         
%ͼ

 PROTOTYPE :
 Procedure List_TagAllItems (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Tag all items in the list.                                       
 NB.....: Run only if the "Multiselection" bit is set.                     
 SEE ALSO..: 
    ~List_UnTagAllItem~
    ~List_ToggleAllItem~

:List_UnTagAllItems
%ͻ
%                       Procedure List_UnTagAllItems                        
%ͼ

 PROTOTYPE :
 Procedure List_UnTagAllItems (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Untag all items in the list.                                     
 NB.....: Run only if the "Multiselection" bit is set.                     
 SEE ALSO..: 
    ~List_TagAllItem~
    ~List_ToggleAllItem~

:List_ToggleAllItems
%ͻ
%                       Procedure List_ToggleAllItems                       
%ͼ

 PROTOTYPE :
 Procedure List_ToggleAllItems (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Toggle all items in the list.                                    
 NB.....: Run only if the "Multiselection" bit is set.                     
 SEE ALSO..: 
    ~List_UnTagAllItem~
    ~List_TagAllItem~

:List_SetId
%ͻ
%                           Procedure List_SetId                            
%ͼ

 PROTOTYPE :
 Procedure List_SetId (Var L:TList; Id:Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Id (Word) = New Id to set for the List structure.                
 OUT....: /                                                                
 EXPLAIN: Change the field "Id" of the List.                               
 NB.....: I never done a function so trivial.                              
 SEE ALSO..: 
    ~List_Define~

:List_SetIdMore
%ͻ
%                         Procedure List_SetIdMore                          
%ͼ

 PROTOTYPE :
 Procedure List_SetIdMore (Var L:TList; IdMore:Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          IdMore (Word) = New Id to set for the List structure.            
 OUT....: /                                                                
 EXPLAIN: Change the field "IdMore" of the List.                           
 NB.....: I never done a function so trivial.                              
 SEE ALSO..: 
    ~List_Define~
    ~List_SetId~

:List_SetIdItem
%ͻ
%                         Procedure List_SetIdItem                          
%ͼ

 PROTOTYPE :
 Procedure List_SetIdItem (Var L:TList; Indice:Longint; Id:Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Id (Word) = New Id to set for the Item.                          
 OUT....: /                                                                
 EXPLAIN: Change the field "Id" of an Item.                                

:List_SetTagItem
%ͻ
%                         Procedure List_SetTagItem                         
%ͼ

 PROTOTYPE :
 Procedure List_SetTagItem (Var L:TList; Indice:Longint; Tag:Shortint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Tag (Shortint) = Value to tag in the Item.                       
 OUT....: /                                                                
 EXPLAIN: Tag an Item using a special value.                               

:List_SetUserItem
%ͻ
%                        Procedure List_SetUserItem                         
%ͼ

 PROTOTYPE :
 Procedure List_SetUserItem (Var L:TList; Indice:Longint; User:Shortint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          User (Byte) = Value to set in the "User" field in an Item.       
 OUT....: /                                                                
 EXPLAIN: Set a new value in the field "User" of an Item.                  

:List_SetColorItem
%ͻ
%                        Procedure List_SetColorItem                        
%ͼ

 PROTOTYPE :
 Procedure List_SetColorItem (Var L:TList; Indice,Color:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Color (Longint) = New color for the Item.                        
 OUT....: /                                                                
 EXPLAIN: Change the text color Item.                                      

:List_SetBkColorItem
%ͻ
%                       Procedure List_SetBkColorItem                       
%ͼ

 PROTOTYPE :
 Procedure List_SetBkColorItem (Var L:TList; Indice,Color:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Color (Longint) = New background color for the Item.             
 OUT....: /                                                                
 EXPLAIN: Change the background color for an item (a line).                

:List_SetStringItem
%ͻ
%                       Procedure List_SetStringItem                        
%ͼ

 PROTOTYPE :
 Procedure List_SetStringItem (Var L:TList; Indice:Longint; St:String);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          St (String) = New string for the item.                           
 OUT....: /                                                                
 EXPLAIN: Change the string of an Item (The field "Item").                 

:List_SetStringCell
%ͻ
%                       Procedure List_SetStringCell                        
%ͼ

 PROTOTYPE :
 Procedure List_SetStringCell (Var L:TList; Indice,Col:Longint; ColSt:String)
           ;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Column (Longint) = Column number.                                
          ColSt (String) = New string to set.                              
 OUT....: /                                                                
 EXPLAIN: Set a new string for and Item in a special column (Cell).        
 SEE ALSO..: 
    ~List_GetStringCell~

:List_SetColumnAttr
%ͻ
%                       Procedure List_SetColumnAttr                        
%ͼ

 PROTOTYPE :
 Procedure List_SetColumnAttr (Var L:TList; Column,Size,Justif:Integer);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Integer) = Column number.                                
          Size (Integer) = Size of the column (in pixels).                 
             If Size=-1 the size of the column is not modified.            
          Justif (Integer) = Justification type for the column.            
                    (Text_OnLeft) 0 = Left justify                         
                    (Text_Center) 1 = Center text                          
                   (Text_OnRight) 2 = Right justify                        
 OUT....: /                                                                
 EXPLAIN: Define the fields "Size" and "Justif" for a column.              
 SEE ALSO..: 
    ~List_AdjustColumn~
    ~List_SetColumnId~
    ~List_GetColumnId~

:List_SetColumnId
%ͻ
%                        Procedure List_SetColumnId                         
%ͼ

 PROTOTYPE :
 Procedure List_SetColumnId (Var L:TList; Column:Word; Id:Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Word) = Column number.                                   
          Id (Word) = New "Id" for the column.                             
 OUT....: /                                                                
 EXPLAIN: Set a new "Id" for a column.                                     
 SEE ALSO..: 
    ~List_AdjustColumn~
    ~List_GetColumnId~
    ~SetColumnAttr~

:List_SetColumnColor
%ͻ
%                       Procedure List_SetColumnColor                       
%ͼ

 PROTOTYPE :
 Procedure List_SetColumnColor (Var L:TList; Column,Color:Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Word) = Column number.                                   
          Color (Word) = New color for the column.                         
 OUT....: /                                                                
 EXPLAIN: Set a new color for a column.                                    

:List_SetPosition
%ͻ
%                        Procedure List_SetPosition                         
%ͼ

 PROTOTYPE :
 Procedure List_SetPosition (Var L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 NB.....: Correct position if out of list.                                 
 EXPLAIN: Set a new position for the Item list display position pointer.   

:List_SetSeparator
%ͻ
%                        Procedure List_SetSeparator                        
%ͼ

 PROTOTYPE :
 Procedure List_SetSeparator (Var L:TList; Separator:Char);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Separator (Char) = New separator for the list.                   
 OUT....: /                                                                
 EXPLAIN: Define a new separator for the strings's list.                   
 SEE ALSO..: 
    ~List_Define~

:List_SetTitle
%ͻ
%                          Procedure List_SetTitle                          
%ͼ

 PROTOTYPE :
 Procedure List_SetTitle (Var L:TList; Title:String);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Title (String) = New title for the list.                         
 OUT....: /                                                                
 EXPLAIN: Define a new title for the list.                                 
 SEE ALSO..: 
    ~List_Define~
    ~List_SetSeparator~

:List_SetSortInfo
%ͻ
%                        Procedure List_SetSortInfo                         
%ͼ

 PROTOTYPE :
 Procedure List_SetSortInfo (Var L:TList; Column,Sens:Byte);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Byte) = Column number.                                   
        : Sens (Byte) = Direction to sort datas:                           
                         (Sort_AZ) 0 = Alphabetical order.                 
                         (Sort_ZA) 1 = Reverse order.                      
 OUT....: /                                                                
 EXPLAIN: Define a new separator for the strings's list.                   
 NB.....: This procedure only define the sort parameters,                  
          and don't sort the list.                                         
          To do this, use the function "List_Sort".                        
 SEE ALSO..: 
    ~List_Sort~

:List_SetPathList
%ͻ
%                        Procedure List_SetPathList                         
%ͼ

 PROTOTYPE :
 Procedure List_SetPathList (Var L:TList; Path:String);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Path (String) = Files path.                                      
 OUT....: /                                                                
 EXPLAIN: Define a new file path to use with the columns Bit 1.            
          A column must be declared as a "Files column" to use this feature
 NB.....: If this field is not correctly filled,                           
          the files functions will not run properly.                       

:List_AdjustColumn
%ͻ
%                        Procedure List_AdjustColumn                        
%ͼ

 PROTOTYPE :
 Procedure List_AdjustColumn (Var L:TList; Column:Word);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (WORD) = Column number.                                   
 OUT....: /                                                                
 EXPLAIN: Adjust automatically the column size.                            
 SEE ALSO..: 
    ~List_AdjustColumns~
    ~List_SetColumnId~
    ~List_GetColumnId~

:List_AdjustColumns
%ͻ
%                       Procedure List_AdjustColumns                        
%ͼ

 PROTOTYPE :
 Procedure List_AdjustColumns (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Adjust automatically the columns size.                           
 SEE ALSO..: 
    ~List_AdjustColumn~
    ~List_SetColumnId~
    ~List_GetColumnId~

:List_HideColumn
%ͻ
%                         Procedure List_HideColumn                         
%ͼ

 PROTOTYPE :
 Procedure List_HideColumn (Var L:TList; Column:Word; State:Boolean);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (WORD) = Number of the column to modify.                  
          State (BOOLEAN) = TRUE=Hide column, FALSE=Show column.           
 OUT....: /                                                                
 EXPLAIN: Hide or show a column of the list.                               

:List_GetStringItem
%ͻ
%                        Function List_GetStringItem                        
%ͼ

 PROTOTYPE :
 Function List_GetStringItem ( L:TList; Indice:Longint):String;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: (String) = Get the string of an Item.                            
 EXPLAIN: Get the full string of an Item.                                  

:List_GetStringCell
%ͻ
%                        Function List_GetStringCell                        
%ͼ

 PROTOTYPE :
 Function List_GetStringCell ( L:TList; Indice,Col:Longint):String;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Column (Longint) = Column number.                                
 OUT....: (String) = Get a string.                                         
 EXPLAIN: Get the string of an Item for a special column.                  
 SEE ALSO..: 
    ~List_SetStringCell~

:List_GetColumnNum
%ͻ
%                        Function List_GetColumnNum                         
%ͼ

 PROTOTYPE :
 Function List_GetColumnNum ( L:TList; Column:Byte):Byte;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Word) = Column number.                                   
 OUT....: (Byte) = Get the real number of a column (>1).                   
          If an error occured, then return 0.                              
 EXPLAIN: Get the logical number of a column (The number is set at         
          the initialisation) using the physical number                    
          (The position number of the column).                             
 NB.....: This function is usefull only if the columns are "Movable".      

:List_GetColumnId
%ͻ
%                         Function List_GetColumnId                         
%ͼ

 PROTOTYPE :
 Function List_GetColumnId ( L:TList; Column:Byte):Word;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Byte) = Column number.                                   
 OUT....: (Word) = "Id" of the column.                                     
 EXPLAIN: Get the "Id" of a column.                                        
 SEE ALSO..: 
    ~List_AdjustColumn~
    ~List_SetColumnId~
    ~SetColumnAttr~

:List_GetSizeColumns
%ͻ
%                       Function List_GetSizeColumns                        
%ͼ

 PROTOTYPE :
 Function List_GetSizeColumns ( L:TList):Word;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (Word) = Total size of columns.                                  
 EXPLAIN: Get the total size of the list columns.                          

:List_GetColorLine
%ͻ
%                        Function List_GetColorLine                         
%ͼ

 PROTOTYPE :
 Function List_GetColorLine ( L:TList; Indice:Longint):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (LONGINT) = Item number (Position in list).               
 OUT....: (LONGINT) = Color of the Line.                                   
 EXPLAIN: Return the background line color for the specified indice.       

:List_GetBkColorItem
%ͻ
%                       Function List_GetBkColorItem                        
%ͼ

 PROTOTYPE :
 Function List_GetBkColorItem ( L:TList; Indice:Longint):Integer;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: (INTEGER) = Get the value of the "BkColor" field.                
 NB.....: If an error occured, the returned value is -1.                   
 EXPLAIN: Return the background color of an item.                          

:List_GetUserItem
%ͻ
%                         Function List_GetUserItem                         
%ͼ

 PROTOTYPE :
 Function List_GetUserItem ( L:TList; Indice:Longint):Byte;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: (Byte) = Get the value of the "User" field (0  255).            
 NB.....: If an error occured, the returned value is 0.                    
 EXPLAIN: Get the value of the "User" field of and Item in the list.       

:List_GetIdItem
%ͻ
%                          Function List_GetIdItem                          
%ͼ

 PROTOTYPE :
 Function List_GetIdItem ( L:TList; Indice:Longint):Word;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: (Word) = Get the value of the "Id" field.                        
 NB.....: If an error occured, the returned value is 0.                    
 EXPLAIN: Get the value of the "Id" field of and Item in the list.         
 SEE ALSO..: 
    ~List_TestIdItem~

:List_GetTaggedItem
%ͻ
%                        Function List_GetTaggedItem                        
%ͼ

 PROTOTYPE :
 Function List_GetTaggedItem ( L:TList):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (Longint) = Get the tagged Item position.                        
 EXPLAIN: Get the first tagged Item position.                              
 NB.....: Available only if one and only one Item has been tagged.         
          Return 0 if found none tagged item.                              

:List_GetQttItems
%ͻ
%                         Function List_GetQttItems                         
%ͼ

 PROTOTYPE :
 Function List_GetQttItems ( L:TList):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (LONGINT) = Number of items.                                     
 EXPLAIN: Get quantity of defined items in list.                           

:List_GetQttColumns
%ͻ
%                        Function List_GetQttColumns                        
%ͼ

 PROTOTYPE :
 Function List_GetQttColumns ( L:TList):Byte;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (Byte) = Number of columns.                                      
 EXPLAIN: Get the number of columns defined in the list.                   

:List_GetQttShowItems
%ͻ
%                       Function List_GetQttShowItems                       
%ͼ

 PROTOTYPE :
 Function List_GetQttShowItems( L:TList):Word;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (Word) = Number of Items displayable.                            
 EXPLAIN: Get the number of displayable Items in the List-Box.             

:List_GetAZIndice
%ͻ
%                         Function List_GetAZIndice                         
%ͼ

 PROTOTYPE :
 Function List_GetAZIndice ( L:TList; Item:TListItem; Ordre:Byte):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Item (TListItem) = Item which the position must be found.        
          Ordre (Byte) = (Sort_AZ) 0 = Alphabetical order.                 
                         (Sort_ZA) 1 = Reverse order.                      
 OUT....: (Longint) = Position to insert the Item.                         
 EXPLAIN: Get the Item position using a type of order.                     
 NB.....: If an error occured, the function return 0.                      

:List_GetItemIndice
%ͻ
%                        Function List_GetItemIndice                        
%ͼ

 PROTOTYPE :
 Function List_GetItemIndice ( L:TList; Phrase:String; Column:Byte):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Phrase (String) = Phrase to be searched in List.                 
          Column (Byte) = Column number.                                   
 OUT....: (Longint) = Item position in List.                               
 EXPLAIN: Get the Item position (Indice) in List.                          
 NB.....: If an error occured, the function return 0.                      

:List_GetItemCoord
%ͻ
%                        Function List_GetItemCoord                         
%ͼ

 PROTOTYPE :
 Function List_GetItemCoord ( L:TList; Indice:Longint; Var C:TCoordinates):
          Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          C (TCoordinates) = Structure of coordinates.                     
          Indice (Longint) = Item number (Position in list).               
 OUT....: TRUE / FALSE (Boolean) = TRUE: If Item is displayable.           
 EXPLAIN: Get in the "C" structure the Item coordinates.                   
 SEE ALSO..: 
    ~List_TestMouseOnItem~

:List_GetCellCoord
%ͻ
%                        Function List_GetCellCoord                         
%ͼ

 PROTOTYPE :
 Function List_GetCellCoord ( L:TList; Indice,Column:Longint; Var C:
          TCoordinates):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          C (TCoordinates) = Structure of coordinates.                     
          Indice (Longint) = Item number (Position in list).               
          Column (Longint) = Column number.                                
 OUT....: TRUE / FALSE (Boolean) = TRUE: The cell is displayable.          
 EXPLAIN: Get in the "C" structure the cell coordinates.                   
 SEE ALSO..: 
    ~List_TestMouseOnCell~

:List_GetCellOnMouse
%ͻ
%                       Function List_GetCellOnMouse                        
%ͼ

 PROTOTYPE :
 Function List_GetCellOnMouse ( L:TList; Var Indice,Column:Longint):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: Indice (Longint) = Item number (Position in list).               
          Column (Longint) = Column number.                                
          TRUE / FALSE (Boolean) = TRUE: The mouse is on a cell.           
 EXPLAIN: Get the coordinates of the cell pointed by the mouse pointer.    

:List_GetTaquetCoord
%ͻ
%                       Function List_GetTaquetCoord                        
%ͼ

 PROTOTYPE :
 Function List_GetTaquetCoord ( L:TList; Taquet:Word; Var C:TCoordinates):
          Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Taquet (Word) = Taquet number (Inter-Column).                    
          C (TCoordinates) = Structure of coordinates.                     
 OUT....: TRUE / FALSE (Boolean) = TRUE: If the cell is displayable.       
 EXPLAIN: Get in the "C" structure the Taquet coordinates.                 

:List_GetDirectory
%ͻ
%                        Procedure List_GetDirectory                        
%ͼ

 PROTOTYPE :
 Procedure List_GetDirectory ( Source,Target:String);

 UNIT...: ~Unit MOS_LIS~
 IN.....: Source (String) = Path+Mask for file list.                       
          Target (String) = Filename used to save the list.                
 OUT....: /                                                                
 EXPLAIN: Read directory from a path, build list and save the list.        

:List_GetNextFreeItem
%ͻ
%                       Function List_GetNextFreeItem                       
%ͼ

 PROTOTYPE :
 Function List_GetNextFreeItem( L:TList; Indice:Longint; Sens:Byte):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (LONGINT) = Current item position.                        
          Sens (BYTE) = Direction to Search.                               
              Sort_AZ = 0 (Alphabetical regular).                          
              Sort_ZA = 1 (Alphabetical inverse).                          
 OUT....: (LONGINT) = Indice of free item.                                 
              Return 0 if no free item is found.                           
 EXPLAIN: Search and return the next free item (Not freezed) begining at   
          the position Indice (Indice is tested).                          

:List_GetEditColumn
%ͻ
%                        Function List_GetEditColumn                        
%ͼ

 PROTOTYPE :
 Function List_GetEditColumn ( L:TList):Byte;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (BYTE) = Column number.                                          
          If there isn't editable columns, the function return 0.          
 EXPLAIN: Get the first column "Renamable".                                

:List_Show
%ͻ
%                            Procedure List_Show                            
%ͼ

 PROTOTYPE :
 Procedure List_Show (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Display the list Box with all functionnal gadgets.               
 SEE ALSO..: 
    ~List_Refresh~
    ~List_ShowItem~
    ~List_ShowText~
    ~List_ShowGrid~
    ~List_ShowColumns~
    ~List_ShowSliders~
    ~List_ShowTitle~

:List_ShowItem
%ͻ
%                          Procedure List_ShowItem                          
%ͼ

 PROTOTYPE :
 Procedure List_ShowItem ( L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 EXPLAIN: Display the specified item.                                      
 SEE ALSO..: 
    ~List_Show~
    ~List_ClearLine~

:List_ShowText
%ͻ
%                          Procedure List_ShowText                          
%ͼ

 PROTOTYPE :
 Procedure List_ShowText ( L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 NB.....: If number 0 is specified, the title is displayed.                
 EXPLAIN: Display the Text of a specified Item.                            
 SEE ALSO..: 
    ~List_Show~

:List_ShowTitle
%ͻ
%                         Procedure List_ShowTitle                          
%ͼ

 PROTOTYPE :
 Procedure List_ShowTitle ( L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Display list titles and columns headers.                         
 SEE ALSO..: 
    ~List_Show~

:List_ShowGrid
%ͻ
%                          Procedure List_ShowGrid                          
%ͼ

 PROTOTYPE :
 Procedure List_ShowGrid ( L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Display a grid (Grey lines) using the cells list.                
 SEE ALSO..: 
    ~List_Show~

:List_ShowColumns
%ͻ
%                        Procedure List_ShowColumns                         
%ͼ

 PROTOTYPE :
 Procedure List_ShowColumns ( L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Display the columns lines separations.                           
 SEE ALSO..: 
    ~List_Show~

:List_ShowSliders
%ͻ
%                        Procedure List_ShowSliders                         
%ͼ

 PROTOTYPE :
 Procedure List_ShowSliders (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Define and display Sliders of the list.                          
 NB.....: Must be called before the "List_Refresh" function.               
 SEE ALSO..: 
    ~List_Show~

:List_ClearLine
%ͻ
%                         Procedure List_ClearLine                          
%ͼ

 PROTOTYPE :
 Procedure List_ClearLine ( L:TList; Indice:Longint);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: /                                                                
 EXPLAIN: Clear the Item line in the List box selection.                   
 SEE ALSO..: 
    ~List_ShowItem~

:List_Refresh
%ͻ
%                          Procedure List_Refresh                           
%ͼ

 PROTOTYPE :
 Procedure List_Refresh ( L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Refresh the lists Items.                                         
 SEE ALSO..: 
    ~List_Show~

:List_TestTaggedItem
%ͻ
%                       Function List_TestTaggedItem                        
%ͼ

 PROTOTYPE :
 Function List_TestTaggedItem ( L:TList; Indice:Longint):Shortint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: (Shortint) = Get the Tag value (-128  +127).                    
 NB.....: If an error occured, the returned value is -128.                 
 EXPLAIN: Get the Tag value of an Item in the list.                        

:List_TestIdItem
%ͻ
%                         Function List_TestIdItem                          
%ͼ

 PROTOTYPE :
 Function List_TestIdItem ( L:TList; Indice:Longint; Bit:Word):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Bit (Word) = Bit to test with the "Id" field.                    
 OUT....: (Word) = Get the value of the "Id" field.                        
 NB.....: If an error occured, the returned value is FALSE.                
 EXPLAIN: Test a Bit from the "Id" field of and Item in the list.          
 SEE ALSO..: 
    ~List_GetIdItem~

:List_TestColumnId
%ͻ
%                        Function List_TestColumnId                         
%ͼ

 PROTOTYPE :
 Function List_TestColumnId ( L:TList; Column:Byte; Bit:Word):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Column (Byte) = Column number.                                   
          Bit (Word) = Bit to test with the "Id" field.                    
 OUT....: (Word) = Get the value of the "Id" field.                        
 NB.....: If an error occured, the returned value is FALSE.                
 EXPLAIN: Test a Bit from the "Id" field of and Item in the list.          

:List_TestMouseOnCell
%ͻ
%                       Function List_TestMouseOnCell                       
%ͼ

 PROTOTYPE :
 Function List_TestMouseOnCell( L:TList; Indice,Column:Longint):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
          Column (Longint) = Column number.                                
 OUT....: TRUE / FALSE (Boolean) = TRUE: The mouse is over the Cell.       
 EXPLAIN: Check if the mouse is over a cell surface.                       
 SEE ALSO..: 
    ~List_GetCellCoord~

:List_TestMouseOnItem
%ͻ
%                       Function List_TestMouseOnItem                       
%ͼ

 PROTOTYPE :
 Function List_TestMouseOnItem( L:TList; Indice:Longint):Boolean;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
          Indice (Longint) = Item number (Position in list).               
 OUT....: TRUE / FALSE (Boolean) = TRUE: If the mouse is over an Item.     
 EXPLAIN: Check if the mouse is over an item surface.                      
 SEE ALSO..: 
    ~List_GetItemCoord~

:List_TestMouseOnList
%ͻ
%                       Function List_TestMouseOnList                       
%ͼ

 PROTOTYPE :
 Function List_TestMouseOnList( L:TList):Byte;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (BYTE) = Return the list zone under the mouse pointer :          
             0 = Mouse is not over the list.                               
             1 = Mouse is over the list items.                             
             2 = Mouse is over the list title.                             
 EXPLAIN: Return if mouse pointer is over the list.                        

:List_TestKeys
%ͻ
%                          Function List_TestKeys                           
%ͼ

 PROTOTYPE :
 Function List_TestKeys (Var L:TList):Longint;

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: (Longint) = If an Item selected return Item Indice else 0.       
 EXPLAIN: Check Keyboard keys and manage list selection.                   
 SEE ALSO..: 
    ~List_Test~

:List_TestSizeCol
%ͻ
%                        Procedure List_TestSizeCol                         
%ͼ

 PROTOTYPE :
 Procedure List_TestSizeCol (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Test and manage the columns Taquets (Size of columns).           
 SEE ALSO..: 
    ~List_Test~

:List_TestMoveCol
%ͻ
%                        Procedure List_TestMoveCol                         
%ͼ

 PROTOTYPE :
 Procedure List_TestMoveCol (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Test and manage the moving of list columns.                      
 SEE ALSO..: 
    ~List_Test~

:List_TestSortList
%ͻ
%                        Procedure List_TestSortList                        
%ͼ

 PROTOTYPE :
 Procedure List_TestSortList (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Test and manage the Items sorting.                               
 SEE ALSO..: 
    ~List_Test~

:List_TestInfoBox
%ͻ
%                        Procedure List_TestInfoBox                         
%ͼ

 PROTOTYPE :
 Procedure List_TestInfoBox (Var L:TList);

 UNIT...: ~Unit MOS_LIS~
 IN.....: List (TList) = Pointer to the list structure.                    
 OUT....: /                                                                
 EXPLAIN: Manage the InfoBox gadget.                                       

:COT
%ͻ
%                               Function COT                                
%ͼ

 PROTOTYPE :
 Function COT(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:COSEC
%ͻ
%                              Function COSEC                               
%ͼ

 PROTOTYPE :
 Function COSEC(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCSIN
%ͻ
%                              Function ARCSIN                              
%ͼ

 PROTOTYPE :
 Function ARCSIN(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCCOS
%ͻ
%                              Function ARCCOS                              
%ͼ

 PROTOTYPE :
 Function ARCCOS(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCCOT
%ͻ
%                              Function ARCCOT                              
%ͼ

 PROTOTYPE :
 Function ARCCOT(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCSEC
%ͻ
%                              Function ARCSEC                              
%ͼ

 PROTOTYPE :
 Function ARCSEC(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCCOSEC
%ͻ
%                             Function ARCCOSEC                             
%ͼ

 PROTOTYPE :
 Function ARCCOSEC(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:COSH
%ͻ
%                               Function COSH                               
%ͼ

 PROTOTYPE :
 Function COSH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:COTH
%ͻ
%                               Function COTH                               
%ͼ

 PROTOTYPE :
 Function COTH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:COSECH
%ͻ
%                              Function COSECH                              
%ͼ

 PROTOTYPE :
 Function COSECH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCSINH
%ͻ
%                             Function ARCSINH                              
%ͼ

 PROTOTYPE :
 Function ARCSINH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCCOSH
%ͻ
%                             Function ARCCOSH                              
%ͼ

 PROTOTYPE :
 Function ARCCOSH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCTANH
%ͻ
%                             Function ARCTANH                              
%ͼ

 PROTOTYPE :
 Function ARCTANH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCCOTH
%ͻ
%                             Function ARCCOTH                              
%ͼ

 PROTOTYPE :
 Function ARCCOTH(x:extended): extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCSECH
%ͻ
%                             Function ARCSECH                              
%ͼ

 PROTOTYPE :
 Function ARCSECH(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:ARCCSCH
%ͻ
%                             Function ARCCSCH                              
%ͼ

 PROTOTYPE :
 Function ARCCSCH(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:LOG10
%ͻ
%                              Function LOG10                               
%ͼ

 PROTOTYPE :
 Function LOG10(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:LOGN
%ͻ
%                               Function LOGN                               
%ͼ

 PROTOTYPE :
 Function LOGN(x,Base:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
          Base (EXTENDED) = Logarithm base.                                
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:FAC
%ͻ
%                               Function FAC                                
%ͼ

 PROTOTYPE :
 Function FAC(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:INV
%ͻ
%                               Function INV                                
%ͼ

 PROTOTYPE :
 Function INV(x:extended):extended;

 UNIT...: ~Unit MOS_MAT~
 IN.....: X (EXTENDED) = Input value.                                      
 OUT....: (EXTENDED) = Calculated value.                                   
 EXPLAIN: Calculate value using the above mathematical function.           

:Init_Mouse
%ͻ
%                           Procedure Init_Mouse                            
%ͼ

 PROTOTYPE :
 Procedure Init_Mouse;

 UNIT...: ~Unit MOS_MSE~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Init the graphic mouse.                                          

:Done_Mouse
%ͻ
%                           Procedure Done_Mouse                            
%ͼ

 PROTOTYPE :
 Procedure Done_Mouse;

 UNIT...: ~Unit MOS_MSE~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: "Close" and end the use of graphic mouse.                        

:Coord_PointInScreen
%ͻ
%                       Procedure Coord_PointInScreen                       
%ͼ

 PROTOTYPE :
 Procedure Coord_PointInScreen(Var X,Y:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: (X,Y) (INTEGER) = Coordinates of a point                         
 OUT....: (X,Y) (INTEGER) = Coordinates of the same point or another.      
 EXPLAIN: Put the point in the screen                                      
 EXAMPLE: Coord_PointInScreen(X,Y) with X=-1 and Y=1280                    
          With a mode : 800*600                                            
          The resultat is : (0,599)                                        

:Coord_ClipBox
%ͻ
%                          Function Coord_ClipBox                           
%ͼ

 PROTOTYPE :
 Function Coord_ClipBox(Var VX1,VY1,VX2,VY2:Integer):Boolean;

 UNIT...: ~Unit MOS_TOO~
 IN.....: VX1,VY1,VX2,VY2 (INTEGER) = Box coordinates.                     
 OUT....: VX1,VY1,VX2,VY2 (INTEGER) = New box coordinates.                 
 EXPLAIN: Check the coordinates, and verify if they are in the window      
          clipping. Else, cut coordinates to set in window clipping.       
 NB.....: Return FALSE if the box is totaly hidden, else return TRUE.      

:Coord_BoxInScreen
%ͻ
%                        Procedure Coord_BoxInScreen                        
%ͼ

 PROTOTYPE :
 Procedure Coord_BoxInScreen(Var X1,Y1,X2,Y2:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Coordinate of the box.                   
 OUT....: X1,Y1,X2,Y2 (INTEGER) = New coordinates of the box.              
 EXPLAIN: Check if coordinates are in screen and if they are coherent.     
          If it is not the case, return them coherent !!!                  

:Coord_BoxCorrect
%ͻ
%                        Procedure Coord_BoxCorrect                         
%ͼ

 PROTOTYPE :
 Procedure Coord_BoxCorrect(Var X1,Y1,X2,Y2:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Coordinate of the box.                   
 OUT....: X1,Y1,X2,Y2 (INTEGER) = New coordinates of the box.              
 EXPLAIN: Check if coordinates are not swapped else swap them.             

:Coord_WinInScreen
%ͻ
%                        Procedure Coord_WinInScreen                        
%ͼ

 PROTOTYPE :
 Procedure Coord_WinInScreen(Var x1,y1,x2,y2:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Coordinates of the box                   
 OUT....: X1,Y1,X2,Y2 (INTEGER) = New coordinates of the box               
 EXPLAIN: Check if coordinates are coherent, and put the box in the screen.

:BevelBox
%ͻ
%                            Procedure BevelBox                             
%ͼ

 PROTOTYPE :
 Procedure BevelBox(X1,Y1,X2,Y2,Style,Co:Integer; Cave,Fill:Boolean);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Coodinates of bevelBox on screen.        
          STYLE (INTEGER) = Style of filling.                              
          CO (INTEGER) = Color of the filling.                             
          CAVE (BOOLEAN) = Inversed box or not.                            
          FILL (BOOLEAN) = Fill the box or not.                            
 OUT....: /                                                                
 EXPLAIN: Draw a box in relief on screen.                                  
 EXAMPLE: BevelBox(10,100,130,110,True);                                   

:Display
%ͻ
%                             Procedure Display                             
%ͼ

 PROTOTYPE :
 Procedure Display(X,Y,Cb,Ct:Integer; St:String);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X,Y (INTEGER) = Coordinates of the text do display.              
          Cb,Ct (INTEGER) = Color of the text and the background of screen.
          St (STRING) = String to display.                                 
 EXPLAIN: Draw a text at X,Y with background color Cb and color Ct.        
          Delete what there was at this place.                             
 NB.....: The color of display can be changed using #x with 'x' the color  
          wanted. More colors are possibles in the same sentence.          

:Display_Attr
%ͻ
%                          Procedure Display_Attr                           
%ͼ

 PROTOTYPE :
 Procedure Display_Attr(X,Y,Cb,Ct:Integer; Id:Word; St:String);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X,Y (INTEGER) = Coordinates of the text do display.              
          Cb,Ct (INTEGER) = Color of the text and the screen background.   
          Id (WORD) = Special attributes :                                 
              Bit 0  $0001 : 1 = String in relief                          
              Bit 1  $0002 : 1 = String in shadow                          
              Bit 2  $0004 : 1 = String underlined                         
              Bit 3  $0008 : 1 = Don't clear background                    
          St (STRING) = String to display.                                 
 EXPLAIN: Display a text like the Display function, but allow you to use   
          Special attributes.                                              

:Display_LCD
%ͻ
%                           Procedure Display_LCD                           
%ͼ

 PROTOTYPE :
 Procedure Display_LCD(Px,Py,Color:Integer; Separator:Char; Font:String; 
           FontSize:Byte; Phrase:String);

 UNIT...: ~Unit MOS_TOO~
 IN.....: Px,Py (INTEGER) = Coordinates of the text to display.            
          Color (INTEGER) = Color of the text to display.                  
          Separator (CHAR) = Separator of the mask.                        
          Font (STRING) = Name of the file of the font to use.             
          FontSize (BYTE) = Size of the font to use.                       
          Phrase (STRING) = Text or sentence to display.                   
 OUT....: /                                                                
 EXPLAIN: Display a text using the management of LCD fonts.                

:Display_Colors
%ͻ
%                         Procedure Display_Colors                          
%ͼ

 PROTOTYPE :
 Procedure Display_Colors(X1,Y1,X2,Y2,C1,C2,Sens:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Position of box.                         
          C1,C2 (INTEGER) = First and last color to use.                   
          Sens (INTEGER) = 0=Horizontal, 1=Vertical shade.                 
 OUT....: /                                                                
 EXPLAIN: Fill the box with an horizontal degrade.                         
 EXAMPLE: Display_Colors(50,100,130,110, 240,16);                          

:Draw_Grid
%ͻ
%                            Procedure Draw_Grid                            
%ͼ

 PROTOTYPE :
 Procedure Draw_Grid(x1,y1,x2,y2,pasx,pasy:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Box coordinates.                         
          PasX, PasY (INTEGER) = Step X and Y for grid.                    
 OUT....: /                                                                
 EXPLAIN: Draw a grid in box using defined steps.                          

:Bar_FillGray
%ͻ
%                          Procedure Bar_FillGray                           
%ͼ

 PROTOTYPE :
 Procedure Bar_FillGray(X1,Y1,X2,Y2:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Position of BevelBox on screen.          
 OUT....: /                                                                
 EXPLAIN: Fill the box to gray (Used by "FREEZE_xxx").                     
 EXAMPLE: Bar_FillGray(50,100,130,110);                                    

:Bar_Progress
%ͻ
%                          Procedure Bar_Progress                           
%ͼ

 PROTOTYPE :
 Procedure Bar_Progress(X1,Y1,X2,Y2,Col,Percent:Integer; Id:Word);

 UNIT...: ~Unit MOS_TOO~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Coordinates to display.                  
          Col (INTEGER) = Color to fill the bar.                           
          Percent (INTEGER) = Percentage done.                             
          Id (WORD) = Bits to define the Bar_Progress.                     
              Bit 0  $0001 = Force to draw the box.                        
              Bit 1  $0002 = Never draw the box.                           
 OUT....: /                                                                
 EXPLAIN: Draw a Progress bar using the percent done.                      
 EXAMPLE: Bar_Progress(50,100,190,120,50,$0000);                           

:GetMsg_LightBox
%ͻ
%                         Function GetMsg_LightBox                          
%ͼ

 PROTOTYPE :
 Function GetMsg_LightBox(Var LB:TLightBox; M:Word;T:Byte):Boolean;

 UNIT...: ~Unit MOS_TOO~
 IN.....: LB (TLIGHTBOX) = Record on a variable Light-Box.                 
          M (WORD) = N of the button Souris  Activer.                    
          T (BYTE) = Type of light box (0=Box, 1=Line)                     
 OUT....: LB (TLIGHTBOX) = Record on a variable Light-Box.                 
          (BOOLEAN) = Box draw and finished.                               
 EXPLAIN: Draw and make bigger a box in dotted on screen.                  
          The coordinates of the box drawed can be read by the fields of   
          the record TLightBox.(X1,Y1,X2,Y2).                              
 EXAMPLE: If GetMsg_LightBox(LB,1)=True Then                               
             Write(LB.X1,' ',LB.Y1,' ',LB.X2,' ',LB.Y2);                   

:GetMsg_MoveBox
%ͻ
%                          Function GetMsg_MoveBox                          
%ͼ

 PROTOTYPE :
 Function GetMsg_MoveBox(Var LB:TLightBox; M:Word):Boolean;

 UNIT...: ~Unit MOS_TOO~
 IN.....: LB (TLIGHTBOX) = Record on variable Light-Box.                   
          M (WORD) = N of the mouse button to test.                       
 OUT....: (BOOLEAN) = TRUE if box is moved                                 
 EXPLAIN: Allow you the moving of a box.                                   
 NB.....: The coordinates of box must be defines before the call of the    
          function GetMsg_MoveBox.                                         
 EXAMPLE: LB1.X1:=100; LB1.Y1:=100; LB1.X2:=300; LB1.Y2:=160;              
          If GetMsg_MoveBox(LB1,1)=True Then Write(#7);                    
 SEE ALSO..: 
    ~GetMsg_LightBox~

:Col_BuildShade
%ͻ
%                         Procedure Col_BuildShade                          
%ͼ

 PROTOTYPE :
 Procedure Col_BuildShade(Col1,Col2:Integer);

 UNIT...: ~Unit MOS_TOO~
 IN.....: Col1,COl2 (INTEGER) = First and last color.                      
 OUT....: /                                                                
 EXPLAIN: Build a shade between two colors.                                
 EXAMPLE: Col_BuildShade(16,31);                                           

:Hard_GetTicks
%ͻ
%                          Function Hard_GetTicks                           
%ͼ

 PROTOTYPE :
 Function Hard_GetTicks:Word;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (WORD) = Return Ticks.                                           
 EXPLAIN: Get the current ticks and return the value.                      

:Hard_TestEMM
%ͻ
%                           Function Hard_TestEMM                           
%ͼ

 PROTOTYPE :
 Function Hard_TestEMM:Boolean;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if it's Ok.                                     
 EXPLAIN: Test if there is an expanded memory manager, EMM386.             
 NB.....: Not tested with QEMM.                                            

:Hard_TestLinux
%ͻ
%                          Function Hard_TestLinux                          
%ͼ

 PROTOTYPE :
 Function Hard_TestLinux:Boolean;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if you are in a Linux DOSemu session.           
 EXPLAIN: Detect Linux OS.                                                 
 SEE ALSO..: 
    ~Hard_TestOS2~
 NB.....: This function use two methods (which are "official") to detect   
          Linux. First if Linux is present, the BIOS date string at        
          0xF000:0xFFF5 should be "02/25/93". Second interrupt $E6 called  
          with ah = 0 should return $AA55 in ax register when in a Linux   
          DOS box. Note that interrupt $E6 should be "initialized" to      
          point to an IRET instruction since it is often pointed on        
          nothing by BIOS.                                                 

:Hard_TestMSCDEX
%ͻ
%                         Function Hard_TestMSCDEX                          
%ͼ

 PROTOTYPE :
 Function Hard_TestMSCDEX:Boolean;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if it's Ok.                                     
 EXPLAIN: Test if MSCDEX is loaded.                                        

:Hard_Test4DOS
%ͻ
%                          Function Hard_Test4DOS                           
%ͼ

 PROTOTYPE :
 Function Hard_Test4DOS:Boolean;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if it's Ok.                                     
 EXPLAIN: Test if the OS is 4DOS.                                          
 SEE ALSO..: 
    ~Hard_Get4DOSVersion~

:Hard_TestJoystick
%ͻ
%                        Function Hard_TestJoystick                         
%ͼ

 PROTOTYPE :
 Function Hard_TestJoystick:Boolean;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if it's Ok.                                     
 EXPLAIN: Test if there is a game card or a Joystick port.                 

:Hard_GetPort
%ͻ
%                           Function Hard_GetPort                           
%ͼ

 PROTOTYPE :
 Function Hard_GetPort(Id:Word):Word;

 UNIT...: ~Unit MOS_HAR~
 IN.....: Id (WORD) = Id to select what port you want to get.              
          Direct value is possible, but it's better if you use labels.     
             Port_COM1     = $0400                                         
             Port_COM2     = $0402                                         
             Port_COM3     = $0404                                         
             Port_COM4     = $0406                                         
             Port_LPT1     = $0408                                         
             Port_LPT2     = $040A                                         
             Port_LPT3     = $040C                                         
             Port_LPT4     = $040E                                         
             Port_VideoCard= $0463                                         
 OUT....: (WORD) = Return port value.                                      
 EXPLAIN: Get the current port value. Work only in the segment $0000.      
 NB.....: Return a decimal Word.                                           

:Hard_GetBusType
%ͻ
%                         Function Hard_GetBusType                          
%ͼ

 PROTOTYPE :
 Function Hard_GetBusType:String;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (STRING) = ASCII bus description.                                
             EISA, MCA, PCI and ISA bus are detected.                      
 EXPLAIN: Return the detected bus type.                                    

:Hard_Get4DOSVersion
%ͻ
%                       Function Hard_Get4DOSVersion                        
%ͼ

 PROTOTYPE :
 Function Hard_Get4DOSVersion:String;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (STRING) = The 4DOS version.                                     
 EXPLAIN: Get the 4DOS version if it's loaded.                             
 NB.....: Check if 4DOS is previously loaded.                              
 SEE ALSO..: 
    ~Hard_Test4DOS~

:Hard_GetCMOSValue
%ͻ
%                        Function Hard_GetCMOSValue                         
%ͼ

 PROTOTYPE :
 Function Hard_GetCMOSValue(Addr:Byte):Byte;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BYTE) = Return a CMOS value.                                    
 EXPLAIN: Get a CMOS value reading in the CMOS table.                      

:Hard_TestCMOSCheckSum
%ͻ
%                      Function Hard_TestCMOSCheckSum                       
%ͼ

 PROTOTYPE :
 Function Hard_TestCMOSCheckSum:Boolean;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (BOOLEAN) = TRUE if CMOS checksum is Ok.                         
 EXPLAIN: Performs a checksum on CMOS and returns TRUE if it's ok.         

:Hard_GetFloppyType
%ͻ
%                        Function Hard_GetFloppyType                        
%ͼ

 PROTOTYPE :
 Function Hard_GetFloppyType(Lecteur:Byte):String;

 UNIT...: ~Unit MOS_HAR~
 IN.....: Lecteur (BYTE) = (1=A:, 2=B:).                                   
 OUT....: (STRING) = Return the Floppy type.                               
 EXPLAIN: Get the type of a Floppy.                                        

:Hard_GetBaseRAM
%ͻ
%                         Function Hard_GetBaseRAM                          
%ͼ

 PROTOTYPE :
 Function Hard_GetBaseRAM:Longint;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (LONGINT) = Return the base memory quantity (640Kb usually).     
 EXPLAIN: Get the base RAM value in Kb.                                    

:Hard_GetHDType
%ͻ
%                          Function Hard_GetHDType                          
%ͼ

 PROTOTYPE :
 Function Hard_GetHDType(Hd:Byte):Byte;

 UNIT...: ~Unit MOS_HAR~
 IN.....: HD (BYTE) = (1=HD 1, 2=HD 2).                                    
 OUT....: (LONGINT) = Return the HD type.                                  
 EXPLAIN: Get the HD type as declared in the BIOS (Ex: 47 = User type).    

:Hard_GetComputerType
%ͻ
%                       Function Hard_GetComputerType                       
%ͼ

 PROTOTYPE :
 Function Hard_GetComputerType:String;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (STRING) = The computer type.                                    
 EXPLAIN: Get the computer type (The PC Model).                            

:Hard_GetProcessorType
 DOCUMENTATION NOT FOUND
:Hard_GetProcessorSpeed
 DOCUMENTATION NOT FOUND
:Hard_GetCoProcessorType
 DOCUMENTATION NOT FOUND
:Bios_GetDate
%ͻ
%                           Function Bios_GetDate                           
%ͼ

 PROTOTYPE :
 Function Bios_GetDate:String;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (STRING) = Bios date.                                            
 EXPLAIN: Return the inner BIOS date.                                      

:Hard_IsCdRom
 DOCUMENTATION NOT FOUND
:Hard_GetVideoCardFirm
%ͻ
%                      Function Hard_GetVideoCardFirm                       
%ͼ

 PROTOTYPE :
 Function Hard_GetVideoCardFirm:String;

 UNIT...: ~Unit MOS_HAR~
 IN.....: /                                                                
 OUT....: (STRING) = The manufacturer name.                                
 EXPLAIN: Get the video card manufacturer name.                            



:Extended_Colors
%ͻ
%                         Procedure Extended_Colors                         
%ͼ

 PROTOTYPE :
 Procedure Extended_Colors;

 UNIT...: ~Unit MOS_COL~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Switch to Extended colors.                                       

:Col_SetPaletteToGrey
%ͻ
%                      Procedure Col_SetPaletteToGrey                       
%ͼ

 PROTOTYPE :
 Procedure Col_SetPaletteToGrey(Var Pal:TPalette256; Debut,Fin:Byte);

 UNIT...: ~Unit MOS_COL~
 IN.....: Pal (TPalette256) = Pointer to a palette structure.              
          Debut,Fin (BYTE) = First and last color to modify.               
 OUT....: /                                                                
 EXPLAIN: Modify the colors of a palette to set the image in grey scale.   

:Col_TogglePalette
%ͻ
%                        Procedure Col_TogglePalette                        
%ͼ

 PROTOTYPE :
 Procedure Col_TogglePalette(Var Pal:TPalette256; Debut,Fin:Byte);

 UNIT...: ~Unit MOS_COL~
 IN.....: Pal (TPalette256) = Pointer to a palette structure.              
          Debut,Fin (BYTE) = First and last color to modify.               
 OUT....: /                                                                
 EXPLAIN: Toggle the colors in a palette to negative an image.             

:Col_FillPalette
%ͻ
%                         Procedure Col_FillPalette                         
%ͼ

 PROTOTYPE :
 Procedure Col_FillPalette(Var Pal:TPalette256;Col1,Col2,R,G,B:Byte);

 UNIT...: ~Unit MOS_COL~
 IN.....: Pal (TPALETTE256) = Palette to modify.                           
          Col1 (BYTE) = First color to change                              
          Col2 (BYTE) = Last color to change                               
          R,G,B (BYTE) = Color to set between Col1 to Col2 (0 to 63 only)  
 OUT....: /                                                                
 EXPLAIN: Modify the palette and set the colors between Col1 to Col2       
          at the R,G,B color.                                              

:Col_FadeIn
%ͻ
%                           Procedure Col_FadeIn                            
%ͼ

 PROTOTYPE :
 Procedure Col_FadeIn(R,G,B,Speed:Byte);

 UNIT...: ~Unit MOS_COL~
 IN.....: R,G,B (BYTE) = Red, Green Blue values of a color. (0 to 63 only) 
          Speed (BYTE) = Speed of the Fade.                                
 OUT....: /                                                                
 EXPLAIN: Modify the colors of the screen and set all color to the         
          R,G,B color. This change could be more or less slow with speed   
          parameter                                                        
 SEE ALSO..: 
    ~Col_FadeOut~

:Col_FadeOut
%ͻ
%                           Procedure Col_FadeOut                           
%ͼ

 PROTOTYPE :
 Procedure Col_FadeOut(NewPal:TPalette256; Speed:Byte);

 UNIT...: ~Unit MOS_COL~
 IN.....: NewPal (TPALETTE256) = Palette to fade to.                       
          Speed (BYTE) = Speed of the Fade.                                
 OUT....: /                                                                
 EXPLAIN: Modify the colors of the screen to this palette.                 
 SEE ALSO..: 
    ~Col_FadeIn~

:HSV_To_RGB
%ͻ
%                           Procedure HSV_To_RGB                            
%ͼ

 PROTOTYPE :
 Procedure HSV_To_RGB(H,S,V:Real; Var R,G,B:Real);

 UNIT...: ~Unit MOS_COL~
 IN.....: H,S,V (REAL) = HSV values for the color.                         
 OUT....: R,G,B (REAL) = RGB values for the color.                         
 EXPLAIN: Convert the HSV values in RGB values for a color.                
 NB.....: from the source GIF.PAS, self extracted from the sources of      
          Persistence Of Vision (POV), refered by                          
          "Computer Graphics", Donald Hearn & M. Pauline Baker, p. 304.    

:Lower
%ͻ
%                              Function Lower                               
%ͼ

 PROTOTYPE :
 Function Lower(SUP:String):String;

 UNIT...: ~Unit MOS_STR~
 IN.....: SUP (STRING) = Input String                                      
 OUT....: (STRING) = String result                                         
 EXPLAIN: Transform a string to small letters.                             
 EXAMPLE: Writeln(Lower('FREderic')) ='frederic'                           
 SEE ALSO..: 
    ~Upper~
    ~Midder~

:Check_Base
%ͻ
%                            Function Check_Base                            
%ͼ

 PROTOTYPE :
 Function Check_Base(St:String;Base:Byte):Boolean;

 UNIT...: ~Unit MOS_STR~
 IN.....: St : (STRING) = Number in a base between 2..36                   
          Base : (BYTE) = Base                                             
 OUT....: (BOOLEAN) : True  = The number St is correct in this base        
                      False = The number St contain incorrect char to be   
                              in this base.                                
 EXPLAIN: Test if a number is in the correct base, and so if it can be     
          converted.                                                       
 BUGS...: Numbers <0.                                                      

:Crypt_String
%ͻ
%                           Function Crypt_String                           
%ͼ

 PROTOTYPE :
 Function Crypt_String(Phr:String; Clef:Byte):String;

 UNIT...: ~Unit MOS_STR~
 IN.....: Phr (STRING) = Sentence to Crypt_String                          
          Clef (BYTE) = Key for the Crypt_String.                          
 OUT....: Res (STRING) = Cypted sentence.                                  
 EXPLAIN: Crypt_String / Uncrypt a sentence with a crypt key               

:Get_CryptKey
%ͻ
%                           Function Get_CryptKey                           
%ͼ

 PROTOTYPE :
 Function Get_CryptKey(Phr:String):Byte;

 UNIT...: ~Unit MOS_STR~
 IN.....: Phr (STRING) = Sentence witch we want the key.                   
 OUT....: Res (BYTE) = Key  (0 <-> 255).                                   
 EXPLAIN: Generate a Key (BYTE) associated to the string.                  

:Cmp_Date
%ͻ
%                             Function Cmp_Date                             
%ͼ

 PROTOTYPE :
 Function Cmp_Date(D1,D2:TDate):Boolean;

 UNIT...: ~Unit MOS_STR~
 IN.....: D1,D2 : (TDate) = 2 dates to be compared                         
 OUT....: (BOOLEAN) : True  = D1<D2                                        
                      False = D1>=D2                                       
 EXPLAIN: Test if a date in below than an other.                           

:Execute_Base
%ͻ
%                          Procedure Execute_Base                           
%ͼ

 PROTOTYPE :
 Procedure Execute_Base(Path, CmdLine : String;Flg:word);

 UNIT...: ~Unit MOS_SWAP~
 IN.....: Path    (STRING) : Path + NameFile + Extension                   
          Cmdline (STRING) : Command line parameter                        
          Flg     (WORD)   :                                               
 OUT....: /                                                                
 EXPLAIN: This procedure is very powerful because it free a maximum of     
          conventional memory useful to the program to execute.            
          It swap the contain of memory to disk.                           
 BUGS   : The programer must put all the interrupts like before they was   
          set to other values :                                            
          Idem for XMS allocation (Previous XMS allocation must be free)   
 EXAMPLE: Path = 'c:\utils\arj.exe'                                        
          Cmdline = '-?'                                                   
          The programer have to make like this example :                   
          Restore_Old_Interrupt;                                           
          Execute_Base('c:\utils\arj.exe','-?',$FFFF);                     
          New_Interrupt;                                                   
 SEE ALSO..: 
    ~DOS_Shell~
 CF.....: Exec from Tp7                                                    

:DOS_Shell
%ͻ
%                            Procedure DOS_Shell                            
%ͼ

 PROTOTYPE :
 Procedure DOS_Shell;

 UNIT...: ~Unit MOS_SWAP~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Return to DOS and free maximum of memory.                        
          To come back to the program we quit, you have only to hit "exit" 
          on the keyboard.                                                 
 BUGS   : The programer must put all the interrupts like before they was   
          set to other values :                                            
          Idem for XMS allocation (Previous XMS allocation must be free)   
 EXAMPLE: The programer must do like this example :                        
          Restore_old_interrupt;                                           
          doc_shell;                                                       
          New_interrupt;                                                   
          Free all XMS used, else prepare you boot again...                
 SEE ALSO..: 
    ~Execute_Base~

:DefSys_Mouse
%ͻ
%                          Procedure DefSys_Mouse                           
%ͼ

 PROTOTYPE :
 Procedure DefSys_Mouse(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: Mouse System Requester. Set parameters for the mouse.            

:DefSys_Keyboard
%ͻ
%                         Procedure DefSys_Keyboard                         
%ͼ

 PROTOTYPE :
 Procedure DefSys_Keyboard(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the keyboard.               

:DefSys_Screen
%ͻ
%                          Function DefSys_Screen                           
%ͼ

 PROTOTYPE :
 Function DefSys_Screen(Px,Py,Mode:Integer; Title:String):Integer;

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position.                            
          Mode (INTEGER) = Selected mode.                                  
          Title (STRING) = Requester title.                                
 OUT....: (INTEGER) = Return the selected graphic mode.                    
 EXPLAIN: Allow user to select an enable graphics mode in the modes list.  

:DefSys_Colors
%ͻ
%                          Procedure DefSys_Colors                          
%ͼ

 PROTOTYPE :
 Procedure DefSys_Colors(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the MOS colors.             

:DefSys_Misc
%ͻ
%                           Procedure DefSys_Misc                           
%ͼ

 PROTOTYPE :
 Procedure DefSys_Misc(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for miscellaneous MOS parts.    

:DefSys_Blankers
%ͻ
%                         Procedure DefSys_Blankers                         
%ͼ

 PROTOTYPE :
 Procedure DefSys_Blankers(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the MOS screen blankers.    

:DefSys_Errors
%ͻ
%                          Procedure DefSys_Errors                          
%ͼ

 PROTOTYPE :
 Procedure DefSys_Errors(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for manage the MOS errors.      

:DefSys_ErrorsHistory
%ͻ
%                      Procedure DefSys_ErrorsHistory                       
%ͼ

 PROTOTYPE :
 Procedure DefSys_ErrorsHistory(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Get history for errors.                        

:DefSys_Fonts
%ͻ
%                          Procedure DefSys_Fonts                           
%ͼ

 PROTOTYPE :
 Procedure DefSys_Fonts(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the Fonts.                  

:DefSys_Sounds
%ͻ
%                          Procedure DefSys_Sounds                          
%ͼ

 PROTOTYPE :
 Procedure DefSys_Sounds(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for sounds.                     

:DefSys_Graphics
%ͻ
%                         Procedure DefSys_Graphics                         
%ͼ

 PROTOTYPE :
 Procedure DefSys_Graphics(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the MOS visual aspect.      

:DefSys_Locale
%ͻ
%                          Procedure DefSys_Locale                          
%ͼ

 PROTOTYPE :
 Procedure DefSys_Locale(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for languages.                  

:DefSys_System
%ͻ
%                          Procedure DefSys_System                          
%ͼ

 PROTOTYPE :
 Procedure DefSys_System(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the MOS system directory.   

:DefSys_Network
%ͻ
%                         Procedure DefSys_Network                          
%ͼ

 PROTOTYPE :
 Procedure DefSys_Network(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the NOVELL Network (IPX).   

:DefSys_Security
%ͻ
%                         Procedure DefSys_Security                         
%ͼ

 PROTOTYPE :
 Procedure DefSys_Security(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the security.               

:DefSys_TimeBelt
%ͻ
%                         Procedure DefSys_TimeBelt                         
%ͼ

 PROTOTYPE :
 Procedure DefSys_TimeBelt(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the Time-Belt.              

:DefSys_Date
%ͻ
%                           Function DefSys_Date                            
%ͼ

 PROTOTYPE :
 Function DefSys_Date(Px,Py,Mode:Integer):String;

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the date.                   

:DefSys_Time
%ͻ
%                           Procedure DefSys_Time                           
%ͼ

 PROTOTYPE :
 Procedure DefSys_Time(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Set parameters for the time.                   

:DefSys_Printers
%ͻ
%                         Procedure DefSys_Printers                         
%ͼ

 PROTOTYPE :
 Procedure DefSys_Printers(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: Px,Py (INTEGER) = Requester position on screen.                  
 OUT....: /                                                                
 EXPLAIN: System requester. Reset the printer.                             

:Display_RuntimeErrors
%ͻ
%                      Procedure Display_RuntimeErrors                      
%ͼ

 PROTOTYPE :
 Procedure Display_RuntimeErrors(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Display the Runtimes errors list managed by MOS.                 

:Display_MOSErrors
%ͻ
%                        Procedure Display_MOSErrors                        
%ͼ

 PROTOTYPE :
 Procedure Display_MOSErrors(Px,Py:Integer);

 UNIT...: ~Unit MOS_SYS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Display the MOS errors list managed by MOS.                      


:Execute_MOS
%ͻ
%                           Procedure Execute_MOS                           
%ͼ

 PROTOTYPE :
 Procedure Execute_MOS(Path, CmdLine:String);

 UNIT...: ~Unit MOS_TSK~
 IN......: Path (STRING) = Path + Filename of the program to run.          
           CmdLine (STRING) = Parameters for the program.                  
 OUT.....: /                                                               
 EXPLAIN.: Execute a MOS program without going to DOS.                     
 NB......: Please be sure that the program to run is really a MOS program. 

:Call_System
%ͻ
%                           Procedure Call_System                           
%ͼ

 PROTOTYPE :
 Procedure Call_System(CmdLine:String);

 UNIT...: ~Unit MOS_TSK~
 IN.....: CmdLine (STRING) = Command line input.                           
 OUT....: /                                                                
 EXPLAIN: Call a tool (Procedure or Function) from the SYSTEM.EXE library. 
          You have to specify some parameters in the command line :        
               -MSA          : (INTEGER) = Specify the wanted requester.   
               -WPX          : (INTEGER) = X position of the window.       
               -WPY          : (INTEGER) = Y position of the window.       
               -PS1=FILE.INI : (STRING) =  Use the specified INI file.     
          List of available requesters (Sorted by numbers) :               
                1: System_Request                                          
                2: Net_RequestG                                            
                3: Req_Memory                                              
                4: Req_Hardware                                            
                5: Req_Calculator                                          
               61: DEFSYS_MOUSE                                            
               62: DEFSYS_KEYBOARD                                         
               63: DEFSYS_SCREEN                                           
               64: DEFSYS_COLORS                                           
               65: DEFSYS_MISC                                             
               66: DEFSYS_BLANKERS                                         
               67: DEFSYS_SOUNDS                                           
               68: DEFSYS_ERRORS                                           
               69: DEFSYS_FONT                                             
               70: DEFSYS_GRAPHICS                                         
               71: DEFSYS_LOCALE                                           
               72: DEFSYS_DISK                                             
               73: DefSys_Network                                          
               74: DefSys_Security                                         
               75: DefSys_TimeBelt                                         
               76: DEFSYS_DATE                                             
               77: DEFSYS_TIME                                             
               78: DefSys_Printers                                         
               91: NET_RequestG                                            
               92: NET_ServerInfos                                         
               93: NET_Connection                                          
               94: NET_Login                                               
               95: NET_Messages                                            
               96: NET_SessionUserList                                     
 EXAMPLE: Call_System('-MSA=1 -WPX=53 -WPY=26 -PS1=TOTO.INI');             

:Close_MOS
%ͻ
%                            Procedure Close_MOS                            
%ͼ

 PROTOTYPE :
 Procedure Close_MOS;

 UNIT...: ~Unit MOS_TSK~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Finish imediatly the program and return to DOS.                  
 NB.....: This procedure must be called only if a serious problem occured. 

:Init_Screen
%ͻ
%                           Procedure Init_Screen                           
%ͼ

 PROTOTYPE :
 Procedure Init_Screen;

 UNIT...: ~Unit MOS_TSK~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Initialise the graphic screen.                                   

:Done_Screen
%ͻ
%                           Procedure Done_Screen                           
%ͼ

 PROTOTYPE :
 Procedure Done_Screen;

 UNIT...: ~Unit MOS_TSK~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Restore the initial text screen.                                 

:Button
%ͻ
%                             Procedure Button                              
%ͼ

 PROTOTYPE :
 Procedure Button(X,Y,Sx,Sy:Integer; CoP,CoB:Byte; Id:Word; Var But:TButton; 
           St:String);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Button coordinates.                              
          Sx (INTEGER) = Horizontal button size in pixels.                 
          Sy (INTEGER) = Vertical button size in pixels :                  
                If size is set to -1, the size is automatically ajusted    
                to the current font size.                                  
          CoP (BYTE) = Text color.                                         
          CoB (BYTE) = Background color.                                   
          Id (BYTE) = Button bits definitions :                            
                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 = Display image in the button :           
                               Only ICO, BMP and MGF format are supported. 
                               Path  and filename are the button label.    
                   NB : You can define two BMP images for your button      
                        Example : 'UNPRESS.BMP|PRESSED.BMP'.               
                Bit 4  $0010 : 1 = Pointer become "Hand" over the button   
                Bit 5  $0020 : 1 = Constant color when button is clicked.  
                Bit 6  $0040 : 1 = Text shifted when button is clicked.    
                Bit 7  $0080 : 1 = Send TRUE after delay on button.        
          But1 (TButton) = Pointer to the button structure.                
          Name (STRING) = Button label to be displayed.                    
 EXPLAIN: Define and display a button.                                     
 OUT....: /                                                                
 NB.....: In olders versions of MOS, there was possible to define a locked 
          position for a button. Option is not available now.              
 EXAMPLE: Button(10,50,130,-1,0,7,$70,But1,'Open File');                   
          Button(10,70,35, -1,0,7,$18,But2,'C:\MOS\EYE.ICO');              
 SEE ALSO..: 
    ~Button_Draw~
    ~Button_Freeze~
    ~Button_GetMsg~

:Button_Draw
%ͻ
%                           Procedure Button_Draw                           
%ͼ

 PROTOTYPE :
 Procedure Button_Draw(B:TButton);

 UNIT...: ~Unit MOS_GAD~
 IN.....: But1 (TButton) = Pointer to a Button structure.                  
 OUT....: /                                                                
 EXPLAIN: Display the specified gadget.                                    
 EXAMPLE: Button_Draw(But1);                                               
 SEE ALSO..: 
    ~Button~
    ~Button_Freeze~
    ~Button_GetMsg~

:Button_Freeze
%ͻ
%                          Procedure Button_Freeze                          
%ͼ

 PROTOTYPE :
 Procedure Button_Freeze(Status:Boolean; Var B:TButton);

 UNIT...: ~Unit MOS_GAD~
 IN.....: On/Off (BOOLEAN) = (On = Enable gadget).                         
          But1 (Var TButton) = Pointer to the Button structure.            
 OUT....: /                                                                
 EXPLAIN: Enable or disable the Button gadget.                             
 EXAMPLE: Button_Freeze(On,But1);                                          
 SEE ALSO..: 
    ~Button~
    ~Button_Draw~
    ~Button_GetMsg~

:Button_GetMsg
%ͻ
%                          Function Button_GetMsg                           
%ͼ

 PROTOTYPE :
 Function Button_GetMsg(Var B:TButton; M:Word):Boolean;

 UNIT...: ~Unit MOS_GAD~
 IN.....: But1 (TButton) = Pointer to the Button structure.                
          M (Word) = Activation code.                                      
 OUT....: (BOOLEAN) = TRUE = Gadget selected.                              
 EXPLAIN: Test if the gadget is selected.                                  
 EXAMPLE: If Button_GetMsg(But1,1)=TRUE Then...                            
 SEE ALSO..: 
    ~Button~
    ~Button_Draw~
    ~Button_Freeze~

:Cycler
%ͻ
%                             Procedure Cycler                              
%ͼ

 PROTOTYPE :
 Procedure Cycler(X,Y,Size,Num:Integer; CoP,CoB:Byte; Id:Word; Var C:TCycler;
            St:String);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Cycler coordinates.                              
          Size (INTEGER) = Horizontal Cycler size in pixels.               
          Num (INTEGER) = Label number to be displayed first.              
          CoP (BYTE) = Text color.                                         
          CoB (BYTE) = Background color.                                   
          Id (BYTE) = Cycler bits definitions :                            
                Bit 0  $0001 : 1 = Use image palette to Display Image      
                Bit 1  $0002 : 1 = Freezed Cycler                          
                Bit 2  $0004 : 1 = Unvisible Cycler                        
                Bit 3  $0008 : 1 = Display image in the Cycler :           
                               Only ICO, BMP and MGF format are supported. 
                               Path  and filename are the button label.    
                Bit 4  $0010 : 1 = Pointer become "Hand" over the Cycler   
          Cyc1 (TCycler) = Pointer to the Cycler structure.                
          Name (STRING) = Cycler labels to be displayed.                   
 EXPLAIN: Define and display a gadget Cycler.                              
          A gadget Cycler is a special button that have one or more labels.
 NB.....: Labels must be separated by the '|' caracter.                    
 OUT....: /                                                                
 EXAMPLE: Cycler(10,80,100,1,0,7,$10,Cyc1,'CRUNCH|DECRUNCH|AUTO DETECT|'); 
 SEE ALSO..: 
    ~Cycler_Draw~
    ~Cycler_Freeze~
    ~Cycler_GetMsg~

:Cycler_Draw
%ͻ
%                           Procedure Cycler_Draw                           
%ͼ

 PROTOTYPE :
 Procedure Cycler_Draw(C:TCycler);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Cyc1 (TCycler) = Pointer to a Cycler structure.                  
 OUT....: /                                                                
 EXPLAIN: Display the specified gadget.                                    
 EXAMPLE: Cycler_Draw(Cyc1);                                               
 SEE ALSO..: 
    ~Cycler~
    ~Cycler_Freeze~
    ~Cycler_GetMsg~

:Cycler_Freeze
%ͻ
%                          Procedure Cycler_Freeze                          
%ͼ

 PROTOTYPE :
 Procedure Cycler_Freeze(Status:Boolean; Var C:TCycler);

 UNIT...: ~Unit MOS_GAD~
 IN.....: On/Off (BOOLEAN) = (On = Enable gadget).                         
          Cyc1 (Var TCycler) = Pointer to the Cycler structure.            
 OUT....: /                                                                
 EXPLAIN: Enable or disable the Cycler gadget.                             
 EXAMPLE: Cycler_Freeze(On,Cyc1);                                          
 SEE ALSO..: 
    ~Cycler~
    ~Cycler_Draw~
    ~Cycler_GetMsg~

:Cycler_GetMsg
%ͻ
%                          Function Cycler_GetMsg                           
%ͼ

 PROTOTYPE :
 Function Cycler_GetMsg(Var C:TCycler; M:Word):Boolean;

 UNIT...: ~Unit MOS_GAD~
 IN.....: Cyc1 (TCycler) = Pointer to the Cycler structure.                
          M (Word) = Activation code.                                      
 OUT....: (BOOLEAN) = TRUE = Gadget selected.                              
 EXPLAIN: Test if the gadget is selected.                                  
 EXAMPLE: If Cycler_GetMsg(Cyc1,1)=TRUE Then...                            
 SEE ALSO..: 
    ~Cycler~
    ~Cycler_Draw~
    ~Cycler_Freeze~

:InputText
%ͻ
%                            Procedure InputText                            
%ͼ

 PROTOTYPE :
 Procedure InputText(X,Y,Siz:Integer; Len,CoB,Co2,Sty:Byte; Id:Word; Var C:
           TInputText; Var Cin:String);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Gadget coordinates.                              
          Size (INTEGER) = Gadget width in pixel.                          
          Len (BYTE) = Maximum lenght in chars.                            
          CoB (BYTE) = Background color (When not selected).               
          Co2 (BYTE) = Background color (When selected).                   
          Sty (BYTE) = Design style for the gadget.                        
                       0 = Use StringBox                                   
                       1 = Use BevelBox                                    
                       2 = Without any box                                 
          Id (WORD) = Define gadget comportement.                          
              Bit 0  $0001 = Gadget activated                              
              Bit 1  $0002 = Previous gadget if up arrow                   
              Bit 2  $0004 = Next gadget if down arrow                     
              Bit 3  $0008 = Previous gadget if left arrow                 
              Bit 4  $0010 = Next gadget if right arrow                    
              Bit 5  $0020 = Enable ESC key (Restore string)               
              Bit 6  $0040 = Put this bit if the gadget musn't be tested   
              Bit 7  $0080 = Password mode = No display caracters          
              Bit 8  $0100 = Display numbers only                          
              Bit 9  $0200 = Freeze gadget                                 
              Bit 10 $0400 = Upper chars only                              
              Bit 11 $0800 = Invisible gadget                              
              Bit 12 $1000 = Overwrite mode                                
              Bit 13 $2000 = Set cursor at the begining of the line        
          Inp1 (TInputText) Pointer to the InputText structure.            
          Cin (STRING) = String to be modified by gadget.                  
 OUT....: /                                                                
 EXPLAIN: Define a InputText gadget and allow you to modify a string.      
 EXAMPLE: Cin:='CHANGE THIS SENTENCE';                                     
          InputText(10,10,143,255,7,12,0,$0027,C1,Cin);                    
 NB.....: This gadget use the following keys :                             
          Enter, Delete, Backspace, Begin, End, Right Arrow, Left Arrow.   
 SEE ALSO..: 
    ~InPutText_Freeze~
    ~InputText_GetMsg~

:InputText_Draw
%ͻ
%                         Procedure InputText_Draw                          
%ͼ

 PROTOTYPE :
 Procedure InputText_Draw(C:TInputText);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Inp1 (Var TInputText) = Pointer to the InputText structure.      
 OUT....: /                                                                
 EXPLAIN: Draw the InputText gadget.                                       
 EXAMPLE: InputText_Draw(Inp1);                                            
 SEE ALSO..: 
    ~InputText~
    ~Freeze_InputText~
    ~InputText_GetMsg~

:InPutText_Freeze
%ͻ
%                        Procedure InPutText_Freeze                         
%ͼ

 PROTOTYPE :
 Procedure InPutText_Freeze(Status:Boolean; Var C:TInputText);

 UNIT...: ~Unit MOS_GAD~
 IN.....: On/Off (BOOLEAN) = (On = Enable gadget).                         
          Inp1 (Var TInputText) = Pointer to the InputText structure.      
 OUT....: /                                                                
 EXPLAIN: Enable or disable the InputText gadget.                          
 EXAMPLE: InPutText_Freeze(On,Inp1);                                         
 SEE ALSO..: 
    ~InputText~
    ~InputText_GetMsg~

:InputText_GetMsg
%ͻ
%                         Function InputText_GetMsg                         
%ͼ

 PROTOTYPE :
 Function InputText_GetMsg(Var C:TInputText; Var Cin:String):Boolean;

 UNIT...: ~Unit MOS_GAD~
 IN.....: Inp1 (TInputText) = Pointer to the InputText structure.          
          M (Word) = Activation code.                                      
          Cin1 (STRING) = String to be modified.                           
 OUT....: Cin1 (STRING) = String modified.                                 
 EXPLAIN: Test if the gadget is selected.                                  
 EXAMPLE: If InputText_GetMsg(Inp1,Cin1)=TRUE Then Writeln(Cin1);          
 SEE ALSO..: 
    ~InputText~
    ~InPutText_Freeze~

:InputSlider
%ͻ
%                           Procedure InputSlider                           
%ͼ

 PROTOTYPE :
 Procedure InputSlider(X1,Y1,Sx,Col1,Col2,Style:Integer;Min,Max,Step:Longint;
            Var Value:Longint; Id:Word; Var IS:TInputSlider);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X1,Y1 (INTEGER) = Gadget coordinates.                            
          Sx (INTEGER) = Width of the gadget.                              
          Col1,Col2 (INTEGER) = Colors for the Gadget.                     
          Style (INTEGER) = Gadget Style like InputText Gadget.            
          Min,Max (LONGINT) = Available number array.                      
          Step (LONGINT) = Step to add or dec value in array.              
          Value (LONGINT) = Initial value to modify.                       
          Id (WORD) = Bits definition :                                    
              Bit 0  $0001 : 1 = Gadget Activated                          
              Bit 1  $0002 : 1 = Gadget Freezed                            
              Bit 2  $0004 : 1 = Unvisible Gadget                          
          IS (TInputSlider) = Pointer to the gadget structure.             
 OUT....: /                                                                
 EXPLAIN: Define and draw an InputSlider Gadget.                           
 EXAMPLE: InputSlider(10,50,70,12,13,0,-50,+50,5,Value,$01,Isl1);          
 SEE ALSO..: 
    ~InputSlider_Draw~
    ~InputSlider_Freeze~
    ~InputSlider_GetMsg~

:InputSlider_Draw
%ͻ
%                        Procedure InputSlider_Draw                         
%ͼ

 PROTOTYPE :
 Procedure InputSlider_Draw(Var IS:TInputSlider);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Isl1 (TInputSlider) = Pointer to the InputSlider structure.      
 OUT....: /                                                                
 EXPLAIN: Draw the InputSlider Gadget.                                     
 EXAMPLE: InputSlider_Draw(Isl1);                                          
 SEE ALSO..: 
    ~InputSlider~
    ~InputSlider_Freeze~
    ~InputSlider_GetMsg~

:InputSlider_Freeze
%ͻ
%                       Procedure InputSlider_Freeze                        
%ͼ

 PROTOTYPE :
 Procedure InputSlider_Freeze(Status:Boolean; Var IS:TInputSlider);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Isl1 (TInputSlider) = Pointer to the InputSlider structure.      
 OUT....: /                                                                
 EXPLAIN: Freeze or Unfreeze the InputSlider Gadget.                       
 EXAMPLE: InputSlider_Freeze(On,Isl1);                                     
 SEE ALSO..: 
    ~InputSlider~
    ~InputSlider_Draw~
    ~InputSlider_GetMsg~

:InputSlider_GetMsg
%ͻ
%                        Function InputSlider_GetMsg                        
%ͼ

 PROTOTYPE :
 Function InputSlider_GetMsg(Var IS:TInputSlider; Var VCin:Longint):Boolean;

 UNIT...: ~Unit MOS_GAD~
 IN.....: IS (TInputSlider) = Pointer to the gadget structure.             
 OUT....: VCin (LONGINT) = Get modified value.                             
          (BOOLEAN) = Gadget Activated.                                    
 EXPLAIN: Manage an InputSlider Gadget.                                    
 EXAMPLE: If InputSlider_GetMsg(Isl1,VCin) Then ;                          
 SEE ALSO..: 
    ~InputSlider_Draw~
    ~InputSlider_Freeze~
    ~InputSlider~

:Canvas
%ͻ
%                             Procedure Canvas                              
%ͼ

 PROTOTYPE :
 Procedure Canvas(X1,Y1,X2,Y2,SizeTaq:Integer; Color,IdTaq,Id,MouseBut:Word; 
           Var C:TCanvas);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Canvas coordinates.                      
          SizeTaq (INTEGER) = Half size of a Taquet (In pixels).           
          Color (WORD) = Pen color for the Canvas.                         
          Id (WORD) = Bits definition :                                    
              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 = Polygon Mode                            
              Bit 8  $0100 : * 1 = Proportional canvas size                
          IdTaq (WORD) = Enable Taquets :                                  
              Number  Hexa   Localisation                                  
              Bit 0  $0001 : 1 = Top and Left                              
              Bit 1  $0002 : 1 = Top and Center                            
              Bit 2  $0004 : 1 = Top and Right                             
              Bit 3  $0008 : 1 = Right and Center                          
              Bit 4  $0010 : 1 = Bottom and Right                          
              Bit 5  $0020 : 1 = Bottom and Center                         
              Bit 6  $0040 : 1 = Bottom and Left                           
              Bit 7  $0080 : 1 = Left and Center                           
            Use the following Id values to define :                        
              -> Only the corners = $55                                    
              -> Only the centers = $AA                                    
              -> All the Taquets  = $FF                                    
          MouseBut (WORD) = Mouse button to test Canvas.                   
          Can1 (TCanvas) = Pointer to the Canvas structure.                
 OUT....: /                                                                
 EXPLAIN: Define and draw a Canvas Gadget.                                 
 EXAMPLE: Canvas(10,50,80,70,3,$FF,$10,Can1);                              
 SEE ALSO..: 
    ~Canvas_Draw~
    ~Canvas_Freeze~
    ~Canvas_GetMsg~

:Canvas_Draw
%ͻ
%                           Procedure Canvas_Draw                           
%ͼ

 PROTOTYPE :
 Procedure Canvas_Draw(Var C:TCanvas);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Can1 (TCanvas) = Pointer to the Canvas structure.                
 OUT....: /                                                                
 EXPLAIN: Draw the Canvas Gadget.                                          
 EXAMPLE: Canvas_Draw(Can1);                                               
 SEE ALSO..: 
    ~Canvas~
    ~Canvas_Freeze~
    ~Canvas_GetMsg~

:Canvas_Freeze
%ͻ
%                          Procedure Canvas_Freeze                          
%ͼ

 PROTOTYPE :
 Procedure Canvas_Freeze(Status:Boolean; Var C:TCanvas);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Status (Boolean) = On = Freeze the Canvas.                       
          Can1 (TCanvas) = Pointer to the Canvas structure.                
 OUT....: /                                                                
 EXPLAIN: Freeze or Unfreeze the Canvas Gadget.                            
 EXAMPLE: Canvas_Freeze(Can1);                                             
 SEE ALSO..: 
    ~Canvas~
    ~Canvas_Draw~
    ~Canvas_GetMsg~

:Canvas_GetMsg
%ͻ
%                          Function Canvas_GetMsg                           
%ͼ

 PROTOTYPE :
 Function Canvas_GetMsg(Var C:TCanvas):Boolean;

 UNIT...: ~Unit MOS_GAD~
 IN.....: Can1 (TCanvas) = Pointer to the Canvas structure.                
 OUT....: (BOOLEAN) = TRUE = Canvas Activated.                             
 EXPLAIN: Return if the Canvas Gadget is activated.                        
 EXAMPLE: If Canvas_GetMsg(Can1) Then...                                   
 SEE ALSO..: 
    ~Canvas~
    ~Canvas_Draw~
    ~Canvas_Freeze~

:ColorPalette
%ͻ
%                          Procedure ColorPalette                           
%ͼ

 PROTOTYPE :
 Procedure ColorPalette(X1,Y1,X2,Y2:Integer; MinC,MaxC:Longint;Mea,Border,Id,
           MouseBut:Word; Selected:Longint; Var Cp:TColorPalette);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Gadget coordinates.                      
          MinC,MaxC (Longint) = First and Last Color Pen.                  
          Mea (WORD) = Half Size between two cells in pixels.              
          Border (WORD) = Border style for color cell.                     
                  0 = No border                                            
                  1 = Relief Border                                        
                  2 = Double Relief Border                                 
                  3 = Border Line                                          
          Id (WORD) = Bits definition :                                    
              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                             
          MouseBut (WORD) = Mouse button to test the Palette.              
          Selected (LONGINT) = Initial selected color.                     
          CP (TColorPalette) = Pointer to the gadget structure.            
 OUT....: /                                                                
 EXPLAIN: Define and draw a ColorPalette Gadget.                           
 EXAMPLE: ColorPalette(10,50,70,12,13,0,-50,+50,5,1,$0040,Cp1);            
 SEE ALSO..: 
    ~ColorPalette_Draw~
    ~ColorPalette_Freeze~
    ~ColorPalette_GetMsg~

:ColorPalette_Draw
%ͻ
%                        Procedure ColorPalette_Draw                        
%ͼ

 PROTOTYPE :
 Procedure ColorPalette_Draw(Var CP:TColorPalette);

 UNIT...: ~Unit MOS_GAD~
 IN.....: CP (TColorPalette) = Pointer to the gadget structure.            
 OUT....: /                                                                
 EXPLAIN: Draw a ColorPalette Gadget.                                      
 EXAMPLE: ColorPalette_Draw(Cp1);                                          
 SEE ALSO..: 
    ~ColorPalette~
    ~ColorPalette_Freeze~
    ~ColorPalette_GetMsg~

:ColorPalette_Freeze
%ͻ
%                       Procedure ColorPalette_Freeze                       
%ͼ

 PROTOTYPE :
 Procedure ColorPalette_Freeze(Status:Boolean; Var CP:TColorPalette);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Status (BOOLEAN) = (On = Freeze Gadget).                         
          CP (TColorPalette) = Pointer to the gadget structure.            
 OUT....: /                                                                
 EXPLAIN: Freeze or Unfreeze a ColorPalette Gadget.                        
 EXAMPLE: ColorPalette_Freeze(On,Cp1);                                     
 SEE ALSO..: 
    ~ColorPalette~
    ~ColorPalette_Draw~
    ~ColorPalette_GetMsg~

:ColorPalette_GetMsg
%ͻ
%                       Function ColorPalette_GetMsg                        
%ͼ

 PROTOTYPE :
 Function ColorPalette_GetMsg(Var CP:TColorPalette):Longint;

 UNIT...: ~Unit MOS_GAD~
 IN.....: CP (TColorPalette) = Pointer to the gadget structure.            
 OUT....: (LONGINT) = Selected color number.                               
 EXPLAIN: Manage a ColorPalette Gadget.                                    
          Return the selected color number.                                
 EXAMPLE: If ColorPalette_GetMsg(Cp1)>=0 Then...                           
 SEE ALSO..: 
    ~ColorPalette~
    ~ColorPalette_Draw~
    ~ColorPalette_Freeze~

:InfoBox
%ͻ
%                             Procedure InfoBox                             
%ͼ

 PROTOTYPE :
 Procedure InfoBox(X1,Y1,X2,Y2:Integer; Id:Word; Var I:TInfoBox; Info:String)
           ;

 UNIT...: ~Unit MOS_GAD~
 IN.....: X1,Y1,X2,Y2 (INTEGER) = Info box coordinates.                    
          Id (BYTES) = Bits definition :                                   
              Bit 0  $0001 = Gadget activated                              
              Bit 1  $0002 = Display infos on the right bottom             
              Bit 2  $0004 = Delay for info                                
          Inf1 (TInfoBox) = Pointer to the Info Box structure.             
          Info (STRING) = Message text (Max 255 Chars).                    
 OUT....: /                                                                
 EXPLAIN: Define a help box called when the mouse will be on it.           
 EXAMPLE: InfoBox(10,50,130,70,$00,'Load the selected file',Inf1);         
 SEE ALSO..: 
    ~InfoBox_GetMsg~

:InfoBox_Kill
%ͻ
%                          Procedure InfoBox_Kill                           
%ͼ

 PROTOTYPE :
 Procedure InfoBox_Kill(Var I:TInfoBox);

 UNIT...: ~Unit MOS_GAD~
 IN.....: Inf1 (TInfoBox) = Pointer to the InfoBox structure.              
 OUT....: /                                                                
 EXPLAIN: Kill the InfoBox gadget.                                         
 NB.....: This procedure is not used frequently.                           
 SEE ALSO..: 
    ~InfoBox~
    ~InfoBox_GetMsg~

:InfoBox_GetMsg
%ͻ
%                          Function InfoBox_GetMsg                          
%ͼ

 PROTOTYPE :
 Function InfoBox_GetMsg(Var I:TInfoBox):Boolean;

 UNIT...: ~Unit MOS_GAD~
 IN.....: Inf1 (TInfoBox) = Pointer to the InfoBox structure.              
          M (Word) = Activation code.                                      
 OUT....: (BOOLEAN) = TRUE = Gadget selected.                              
 EXPLAIN: Test if the gadget is selected.                                  
 EXAMPLE: If InfoBox_GetMsg(Inf1)=TRUE Then...                             
 NB.....: Warning this gadgets must be used only with clipped windows.     
 SEE ALSO..: 
    ~InfoBox~

:DrawGad_Cycler
%ͻ
%                         Procedure DrawGad_Cycler                          
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Cycler(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_LeftArrow
%ͻ
%                        Procedure DrawGad_LeftArrow                        
%ͼ

 PROTOTYPE :
 Procedure DrawGad_LeftArrow(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_RightArrow
%ͻ
%                       Procedure DrawGad_RightArrow                        
%ͼ

 PROTOTYPE :
 Procedure DrawGad_RightArrow(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_UpArrow
%ͻ
%                         Procedure DrawGad_UpArrow                         
%ͼ

 PROTOTYPE :
 Procedure DrawGad_UpArrow(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_DownArrow
%ͻ
%                        Procedure DrawGad_DownArrow                        
%ͼ

 PROTOTYPE :
 Procedure DrawGad_DownArrow(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_Close
%ͻ
%                          Procedure DrawGad_Close                          
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Close(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_Swap
%ͻ
%                          Procedure DrawGad_Swap                           
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Swap(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_Extend
%ͻ
%                         Procedure DrawGad_Extend                          
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Extend(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_Size
%ͻ
%                          Procedure DrawGad_Size                           
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Size(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_AmigaOkBut
%ͻ
%                       Procedure DrawGad_AmigaOkBut                        
%ͼ

 PROTOTYPE :
 Procedure DrawGad_AmigaOkBut(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_CheckOff
%ͻ
%                        Procedure DrawGad_CheckOff                         
%ͼ

 PROTOTYPE :
 Procedure DrawGad_CheckOff(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_CheckOn
%ͻ
%                         Procedure DrawGad_CheckOn                         
%ͼ

 PROTOTYPE :
 Procedure DrawGad_CheckOn(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_Lens
%ͻ
%                          Procedure DrawGad_Lens                           
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Lens(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_Question
%ͻ
%                        Procedure DrawGad_Question                         
%ͼ

 PROTOTYPE :
 Procedure DrawGad_Question(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:DrawGad_File
%ͻ
%                          Procedure DrawGad_File                           
%ͼ

 PROTOTYPE :
 Procedure DrawGad_File(X,Y:Integer);

 UNIT...: ~Unit MOS_GAD~
 IN.....: X,Y (INTEGER) = Picture coordinates.                             
 OUT....: /                                                                
 EXPLAIN: Draw specialized picture at coordinates X,Y.                     

:Get_VideoMemorySize
%ͻ
%                       Function Get_VideoMemorySize                        
%ͼ

 PROTOTYPE :
 Function Get_VideoMemorySize:word;

 UNIT...: ~Unit MOS_VESA~
 IN.....: /                                                                
 OUT....: (WORD) = Size in Kbytes of the memory of the video card.         
 EXPLAIN: Get video memory size.                                           
 BUGS...: if <=256Kb, return 0.                                            

:Get_Bank
%ͻ
%                             Function Get_Bank                             
%ͼ

 PROTOTYPE :
 Function Get_Bank:Word;

 UNIT...: ~Unit MOS_VESA~
 IN.....: /                                                                
 OUT....: (WORD) : VESA Bank where we are now !!                           
 EXPLAIN: Get where is VESA Bank now.                                      
          Important : This Functione don't use granularity.                
                      So Bank use in Get_Bank and Set_Bank are different...
 EXAMPLE: Example of save of the VESA bank.                                
          bank:=Get_Bank;                                                  
          ....program....                                                  
          Set_Bank(bank*64 div vesamode.gran);                             
 SEE ALSO..: 
    ~Set_Bank~


:Define_Palette
%ͻ
%                         Procedure Define_Palette                          
%ͼ

 PROTOTYPE :
 Procedure Define_Palette;

 UNIT...: ~Unit MOS_BAS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Define base colors for MOS.                                      

:Get_FileInfoLine
%ͻ
%                         Function Get_FileInfoLine                         
%ͼ

 PROTOTYPE :
 Function Get_FileInfoLine(FName:String; Methode:Byte):String;

 UNIT...: ~Unit MOS_BAS~
 IN.....: FName (STRING) = Filename of the data file.                      
          Methode (BYTE) = Used method to do detection.                    
              M_Extention = 1 : Detection by file suffix (Win95 Method).   
              M_Header    = 2 : Detection by file header (MOS Pro Method). 
 OUT....: (STRING) = Line for file identification.                         
 EXPLAIN: Return the Line for file indentification in the SYSTEM.FTM file. 
 SEE ALSO..: 
    ~Get_FileType~
    ~Get_FileIcon~

:Get_FileType
%ͻ
%                           Function Get_FileType                           
%ͼ

 PROTOTYPE :
 Function Get_FileType(FName:String; Methode:Byte):String;

 UNIT...: ~Unit MOS_BAS~
 IN.....: FName (STRING) = Filename.                                       
          Methode (BYTE) = Used method to do detection.                    
              M_Extention = 1 : Detection by file suffix (Win95 Method).   
              M_Header    = 2 : Detection by file header (MOS Pro Method). 
 OUT....: (STRING) = File identification.                                  
 EXPLAIN: Identify the file and return the identification string.          
 SEE ALSO..: 
    ~Get_FileInfoLine~
    ~Get_FileIcon~

:Get_FileIcon
%ͻ
%                           Function Get_FileIcon                           
%ͼ

 PROTOTYPE :
 Function Get_FileIcon(FName:String; Methode:Byte):String;

 UNIT...: ~Unit MOS_BAS~
 IN.....: FName (STRING) = Filename.                                       
          Methode (BYTE) = Used method to do detection.                    
              M_Extention = 1 : Detection by file suffix (Win95 Method).   
              M_Header    = 2 : Detection by file header (MOS Pro Method). 
 OUT....: (STRING) = Icon Filename.                                        
 EXPLAIN: Get the Icon filename associated to the requested File.          
 SEE ALSO..: 
    ~Get_FileType~
    ~Get_FileInfoLine~

:Loc
%ͻ
%                               Function Loc                                
%ͼ

 PROTOTYPE :
 Function Loc(Indice:Integer):String;

 UNIT...: ~Unit MOS_BAS~
 IN.....: Indice (INTEGER) = Line number of the Label.                     
 OUT....: (STRING) = Return the line number string if exist.               
 NB.....: If the line number don't exist, return "".                       
 EXPLAIN: Manage the Languages files "*.LOC" in the "SYSTEM" directory.    
          Return the string according to the line number in the ".LOC" file
          Users are able to localise their softwares using this function   
          putting the string labels in the three ".LOC" files in 3         
          languages, and get automatically the correct string using the    
          right language calling this function.                            
 SEE ALSO..: 
    ~Change_Language~

:Change_Language
%ͻ
%                         Procedure Change_Language                         
%ͼ

 PROTOTYPE :
 Procedure Change_Language(Num:Byte);

 UNIT...: ~Unit MOS_BAS~
 IN.....: Num (BYTE) = Language number                                     
              L_English  = 1 : English language                            
              L_Francais = 2 : French language                             
              L_Espanol  = 3 : Spain language                              
 OUT....: /                                                                
 EXPLAIN: Change the current language of the MOS interface.                
 SEE ALSO..: 
    ~Loc~

:Get_SystemPath
%ͻ
%                          Function Get_SystemPath                          
%ͼ

 PROTOTYPE :
 Function Get_SystemPath(Path:Byte):String;

 UNIT...: ~Unit MOS_BAS~
 IN.....: Path (BYTE) = Path number (Using labels)                         
              SP_MAIN     =  1 : Main directory                            
              SP_FONTS    =  2 : Font Directory (*.CHR)                    
              SP_ICONS    =  3 : Icons Directory (*.ICO)                   
              SP_IMAGES   =  4 : Images Directory (*.BMP, *.MGF)           
              SP_SOUNDS   =  5 : Sounds Directory (*.WAV)                  
              SP_SWAPS    =  6 : Swapping Directory                        
              SP_TOOLS    =  7 : Tools Directory (*.EXE + Misc)            
              SP_BOOT     =  8 : Boot tools Directory                      
              SP_TEMP     =  9 : Temporary Directory                       
              SP_DATAS    = 10 : Datas system (*.*)                        
              SP_BLANKERS = 11 : Screen Blankers Directory (*.EXE + Misc)  
              SP_SNAPSHOTS= 12 : Screenshots Directory (*.BMP)             
              SP_PALETTES = 13 : Palettes Directory (*.PAL)                
              SP_PATTERNS = 14 : Patterns Directory (*.PAT)                
              SP_TEXTURES = 15 : Textures Directory (*.BMP, *.MGF)         
              SP_BUTTONS  = 16 : Images for button (*.BMP)                 
              SP_MEDIAS   = 17 : CD and other multimedia datas             
              SP_CARDS    = 18 : Games card set recto & verso (*.BMP)      
 OUT....: (STRING) = Expanded Path.                                        
 EXPLAIN: Return the localisation of the "SYSTEM" directory.               

:Get_SystemVersion
%ͻ
%                        Function Get_SystemVersion                         
%ͼ

 PROTOTYPE :
 Function Get_SystemVersion:String;

 UNIT...: ~Unit MOS_BAS~
 IN.....: /                                                                
 OUT....: (STRING) = The MOS system version.                               
 EXPLAIN: Return the installed MOS system version.                         
 EXAMPLE: Writeln(Get_SystemVersion);             Return '3.1'             

:Init_Gfx
%ͻ
%                            Procedure Init_Gfx                             
%ͼ

 PROTOTYPE :
 Procedure Init_Gfx;

 UNIT...: ~Unit MOS_BAS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Initialise graphic mode using 'Gfx_Mode' variable.               

:Load_Config
%ͻ
%                           Function Load_Config                            
%ͼ

 PROTOTYPE :
 Function Load_Config(Name:String):Boolean;

 UNIT...: ~Unit MOS_BAS~
 IN.....: FName (STRING) = Name of the Config file to load an initialise.  
 OUT....: (BOOLEAN) = TRUE if OK, FALSE if there is an error               
 EXPLAIN: Load a .INI file of MOS configuration.                           
 SEE ALSO..: 
    ~Save_Config~

:INIT_BASE
%ͻ
%                            Procedure INIT_BASE                            
%ͼ

 PROTOTYPE :
 Procedure INIT_BASE;

 UNIT...: ~Unit MOS_BAS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Hardware initialisation.                                         
 SEE ALSO..: 
    ~DONE_BASE~

:DONE_BASE
%ͻ
%                            Procedure DONE_BASE                            
%ͼ

 PROTOTYPE :
 Procedure DONE_BASE;

 UNIT...: ~Unit MOS_BAS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Hardware reinitialisation.                                       
 SEE ALSO..: 
    ~INIT_BASE~

:HMA_Request
%ͻ
%                           Procedure HMA_Request                           
%ͼ

 PROTOTYPE :
 Procedure HMA_Request(RequestType:Word);

 UNIT...: ~Unit MOS_XMS~
 IN.....: RequestType (WORD) =                                             
 OUT....: /                                                                
 EXPLAIN: Intent do allocate the 64Ko of HMA memory                        
 NB.....: The RequestType is $FFFF for and applciation or the size of      
          requested if it's a TSR.                                         

:HMA_Release
%ͻ
%                           Procedure HMA_Release                           
%ͼ

 PROTOTYPE :
 Procedure HMA_Release;

 UNIT...: ~Unit MOS_XMS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Free the allocated HMA memory.                                   

:Global_EnableA20
%ͻ
%                        Procedure Global_EnableA20                         
%ͼ

 PROTOTYPE :
 Procedure Global_EnableA20;

 UNIT...: ~Unit MOS_XMS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: /                                                                

:Global_DisableA20
%ͻ
%                        Procedure Global_DisableA20                        
%ͼ

 PROTOTYPE :
 Procedure Global_DisableA20;

 UNIT...: ~Unit MOS_XMS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: /                                                                

:Local_EnableA20
%ͻ
%                         Procedure Local_EnableA20                         
%ͼ

 PROTOTYPE :
 Procedure Local_EnableA20;

 UNIT...: ~Unit MOS_XMS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: /                                                                

:Local_DisableA20
%ͻ
%                        Procedure Local_DisableA20                         
%ͼ

 PROTOTYPE :
 Procedure Local_DisableA20;

 UNIT...: ~Unit MOS_XMS~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: /                                                                

:Init_XMSArray
%ͻ
%                          Function Init_XMSArray                           
%ͼ

 PROTOTYPE :
 Function Init_XMSArray(var Tab:TXMSTab;min,max:longint;var v;Size:Word):
          boolean;

 UNIT...: ~Unit MOS_XMS~
 IN.....: Min (LONGINT) = Minimun index of the array.                      
          Max (LONGINT) = Maximun index of the array.                      
          V (UNTYPED) = The variable of the same type of the array         
                        witch contain the initilizated value of the array  
          Size (WORD) = Mettre toujours Sizeof(V)                          
 OUT....: Tab (TXMSTab) = The array. (Put the name of the array in)        
          (BOOLEAN) = TRUE if array is created, else FALSE.                
 EXPLAIN: Manage an array with very big size (Mo)...                       
          The limit is 64Mo by array.                                      
 SEE ALSO..: 
    ~End_XMSArray~
    ~Get_XMSArray~
    ~Put_XMSArray~

:End_XMSArray
%ͻ
%                          Procedure End_XMSArray                           
%ͼ

 PROTOTYPE :
 Procedure End_XMSArray(tab:TXMSTab);

 UNIT...: ~Unit MOS_XMS~
 IN.....: Tab (TXMSTab) = Name of the array                                
 OUT....: /                                                                
 EXPLAIN: Kill the array (Free the memory allocated by INIT_XMSARRAY)      
          Don't forget to call this procedure because if you don't call    
          in the program, this memory will be lost.                        
 SEE ALSO..: 
    ~Init_XMSArray~

:Get_XMSArray
%ͻ
%                          Procedure Get_XMSArray                           
%ͼ

 PROTOTYPE :
 Procedure Get_XMSArray(tab:TXMSTab;indice:longint;var v);

 UNIT...: ~Unit MOS_XMS~
 IN.....: Tab (TXMSTab) = Name of the array                                
          Indice (LONGINT) = Is the index in the array.                    
 OUT....: V (UNTYPED) = get the variable from XMS to V                     
 EXPLAIN: V will be fill this the value witch will be loaded before in     
          XMS.                                                             
 SEE ALSO..: 
    ~Init_XMSArray~
    ~Put_XMSArray~

:Dsk_Rmdir
%ͻ
%                            Function Dsk_Rmdir                             
%ͼ

 PROTOTYPE :
 Function Dsk_Rmdir(St:String):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: St (STRING) = Directory to remove.                               
 OUT....: (BOOLEAN) = TRUE if no errors, else return FALSE.                
 EXPLAIN: Remove an empty directory.                                       
          This function is much more powerful than Rmdir because if could  
          remove all the sub-directories of a directory if no files are    
          found.                                                           

:Dsk_TestEmptyDir
%ͻ
%                         Function Dsk_TestEmptyDir                         
%ͼ

 PROTOTYPE :
 Function Dsk_TestEmptyDir(S:String):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: S (STRING) = Directory to test.                                  
 OUT....: (BOOLEAN) = TRUE if the directory is empty, else FALSE.          
 EXPLAIN: Test if a directory is empty or not.                             
 NB.....: Empty = contain no files. Sub-dirs are not files.                

:Dsk_ChDir
%ͻ
%                            Function Dsk_ChDir                             
%ͼ

 PROTOTYPE :
 Function Dsk_ChDir(Path:String):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Path(STRING) = Path where the change of the dir must be          
 OUT....: (BOOLEAN) = TRUE if no problem, else FALSE                       
 EXPLAIN: This function is like Chdir of Tp7. But with less bugs.          

:Dsk_TestDirectory
%ͻ
%                        Function Dsk_TestDirectory                         
%ͼ

 PROTOTYPE :
 Function Dsk_TestDirectory(Dir:String):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Dir (STRING) Dir to check for                                    
 OUT....: (BOOLEAN) True if directory exist False elsewhere                
 EXPLAIN: Test if the string is really a directory!                        
 EXAMPLE: Dsk_TestDirectory('c:\utils') Test_dir('..') etc                 

:Dsk_FExpand
%ͻ
%                           Function Dsk_FExpand                            
%ͼ

 PROTOTYPE :
 Function Dsk_FExpand(S:String):String;

 UNIT...: ~Unit MOS_DSK~
 IN.....: S : (STRING) = String input (a filename or a directory)          
 OUT....: (STRING) = String result                                         
 EXPLAIN: Expands a file name into a fully-qualified file name.            
          There is only one difference between FExpand and Dsk_FileExpand :
          A directory will finish with '\' character.                      
 CF.....: FExpand from Dos Tp7 unit.                                       

:Dsk_ValideDirectory
%ͻ
%                       Function Dsk_ValideDirectory                        
%ͼ

 PROTOTYPE :
 Function Dsk_ValideDirectory(Path:String):String;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Path (STRING) = Input path.                                      
 OUT....: Path (STRING) = Output path.                                     
 EXPLAIN: Verify if the path is ended by a '\' and if it's not, it put it. 
 EXAMPLE: Dsk_ValideDirectory('c:\dos') = 'c:\dos\'                        

:Dsk_GetCurrentDirectory
%ͻ
%                     Function Dsk_GetCurrentDirectory                      
%ͼ

 PROTOTYPE :
 Function Dsk_GetCurrentDirectory:String;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: (STRING) = Disk and current path.                                
 EXPLAIN: Return the current path ended by '\'                             
 EXAMPLE: Writeln('Chemin courrant: ',Dsk_GetCurrentDirectory);            
 SEE ALSO..: 
    ~Dsk_GetParentDirectory~

:Dsk_GetParentDirectory
%ͻ
%                      Function Dsk_GetParentDirectory                      
%ͼ

 PROTOTYPE :
 Function Dsk_GetParentDirectory(Dir:String):String;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Dir (STRING) = Input Path                                        
 OUT....: (STRING) = Parent of the input path                              
 EXPLAIN: Get the parent directory, without "..","." etc ...               
 EXAMPLE: Dsk_GetParentDirectory('C:\MOS\FAQ')=c:\mos                      
 NB 1   : If Input Path is the root directory, return the root directory   
 NB 2   : If a disk don't exist, works without problems.                   
 SEE ALSO..: 
    ~Dsk_GetCurrentDirectory~

:Dsk_CreateDirectory
%ͻ
%                       Function Dsk_CreateDirectory                        
%ͼ

 PROTOTYPE :
 Function Dsk_CreateDirectory(Dir:String):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Dir (STRING) = Directory to create.                              
 OUT....: (BOOLEAN) = TRUE if OK, else FALSE.                              
 EXPLAIN: Create the specified directory on the disk.                      
 EXAMPLE: Dsk_CreateDirectory('C:\MOS\FAQ');                               
 NB     : Create the entire path, even if there is more than one directory 
          to create.                                                       

:Dsk_TestRoot
%ͻ
%                           Function Dsk_TestRoot                           
%ͼ

 PROTOTYPE :
 Function Dsk_TestRoot(Dir:String):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Dir (STRING) = Input Path                                        
 OUT....: (BOOLEAN) = TRUE if the path is the root directory, else FALSE.  
 EXPLAIN: Test if it's a root directory                                    
 EXAMPLE: Dsk_TestRoot('C:\MOS\FAQ')=FALSE.                                
 NB.....: If the drive is a substition, return TRUE if Dir is the root of  
          the substition.                                                  
          Subst c:\dos x: , Dsk_TestRoot('x:')= TRUE                       

:Dsk_GetHome
%ͻ
%                           Function Dsk_GetHome                            
%ͼ

 PROTOTYPE :
 Function Dsk_GetHome:String;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: (STRING) = Path of the application.                              
 EXPLAIN: Get the path where the application is launch.                    
 EXAMPLE: Writeln('Path of the application = ',Dsk_GetHome).               
 NB.....: Don't return the '\' on the end of the string.                   

:Dsk_TestWritableDrive
%ͻ
%                      Function Dsk_TestWritableDrive                       
%ͼ

 PROTOTYPE :
 Function Dsk_TestWritableDrive(Drv:TString1):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Drv (CHAR) = Drive letter.                                       
 OUT....: (BOOLEAN) = TRUE if you have the permission to write on this     
                      Drive.                                               
 EXPLAIN: Test if you can write on the drive Drv.                          

:Dsk_GetCurrentDrv
%ͻ
%                        Function Dsk_GetCurrentDrv                         
%ͼ

 PROTOTYPE :
 Function Dsk_GetCurrentDrv:Byte;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: (BYTE) = N of the current drive (A=1, B=2, C=3 ...)             
 EXPLAIN: Return the N of the drive.                                      

:Dsk_GetFirstFloppyDrive
%ͻ
%                     Function Dsk_GetFirstFloppyDrive                      
%ͼ

 PROTOTYPE :
 Function Dsk_GetFirstFloppyDrive:Byte;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: (BYTE) = 1 or 2  (1=A, 2=B)                                      
 EXPLAIN: Get the first floppy drive                                       

:Dsk_MakeFirstFloppyDrive
%ͻ
%                    Procedure Dsk_MakeFirstFloppyDrive                     
%ͼ

 PROTOTYPE :
 Procedure Dsk_MakeFirstFloppyDrive(Drive:Byte);

 UNIT...: ~Unit MOS_DSK~
 IN.....: Drive (BYTE) = 1 or 2 (1=A, 2=B)                                 
 OUT....: /                                                                
 EXPLAIN: Set the first floppy drive.                                      

:Dsk_GetNumOfFloppyDrives
%ͻ
%                     Function Dsk_GetNumOfFloppyDrives                     
%ͼ

 PROTOTYPE :
 Function Dsk_GetNumOfFloppyDrives:Byte;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: (BYTE) = Return the quantity of floppy drives.                   
 EXPLAIN: Get if you have 1 or 2 or 0 floppy drives..                      

:Dsk_GetNumOfDrives
%ͻ
%                        Function Dsk_GetNumOfDrives                        
%ͼ

 PROTOTYPE :
 Function Dsk_GetNumOfDrives:Byte;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: (BYTE) = Number of floppy disk installed.                        
 EXPLAIN: Return the number of floppy disk installed on your PC.           
          Very fast, because read in BIOS...                               

:Dsk_TestDeviceExist
%ͻ
%                       Function Dsk_TestDeviceExist                        
%ͼ

 PROTOTYPE :
 Function Dsk_TestDeviceExist(Root:Char):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Root (CHAR) = Label of the device.                               
 OUT....: (BOOLEAN): True if the device exist.                             
 EXPLAIN: Test if davice esit.                                             
 EXAMPLE: If Dsk_TestDeviceExist('C')=True Then Writeln('"C:" Exis');      
 BUGS...: If drive A is present this function return TRUE for drive b:     

:Dsk_TestPhysicDevice
%ͻ
%                       Function Dsk_TestPhysicDevice                       
%ͼ

 PROTOTYPE :
 Function Dsk_TestPhysicDevice(Root:Char):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Root (CHAR) = Label of the device (Ex : "C")                     
 OUT....: (BOOLEAN): True if it's a physical device.                       
 EXPLAIN: Test if a device is physical or logical.                         
 EXAMPLE: If Dsk_TestPhysicDevice('C')=True Then Writeln('C: is Physical');

:Dsk_TestLocalDevice
%ͻ
%                       Function Dsk_TestLocalDevice                        
%ͼ

 PROTOTYPE :
 Function Dsk_TestLocalDevice(Root:Char):Boolean;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Root (CHAR) = Label of the device (Ex: "C").                     
 OUT....: (BOOLEAN): True if the device is local.                          
 EXPLAIN: Test if the device is Local or Remote.                           
 EXAMPLE: If Dsk_TestLocalDevice('C')=True Then Writeln('"C:" is Local');  

:Dsk_GetDeviceName
%ͻ
%                        Function Dsk_GetDeviceName                         
%ͼ

 PROTOTYPE :
 Function Dsk_GetDeviceName(Root:Char):String;

 UNIT...: ~Unit MOS_DSK~
 IN.....: Root (CHRA) = Label of the device (Ex: "C").                     
 OUT....: (STRING) = Name of the volume                                    
 EXPLAIN: Return the name ot the specified device.                         

:Dsk_ParkDevice
%ͻ
%                         Procedure Dsk_ParkDevice                          
%ͼ

 PROTOTYPE :
 Procedure Dsk_ParkDevice;

 UNIT...: ~Unit MOS_DSK~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Park the head of C and D hard disk.                              



:File_GetNb
%ͻ
%                            Function File_GetNb                            
%ͼ

 PROTOTYPE :
 Function File_GetNb(Source:String;Recurse:Boolean):Longint;

 UNIT...: ~Unit MOS_FIL~
 IN.....: Source (STRING) = First directory where will begin the count     
                            + Mask of the searched files.                  
          Recurse (BOOLEAN) = Search in sub-directory also.                
 OUT....: (LONGINT) = Number of files founded.                             
 EXPLAIN: Search recursively in a directory.                               

:File_Deltree
%ͻ
%                          Procedure File_Deltree                           
%ͼ

 PROTOTYPE :
 Procedure File_Deltree(Source:String);

 UNIT...: ~Unit MOS_FIL~
 IN.....: Source (STRING) = Directory to delete.                           
 OUT....: /                                                                
 EXPLAIN: Delete all the files and directory of the specified path.        

:File_FindBreak
%ͻ
%                         Procedure File_FindBreak                          
%ͼ

 PROTOTYPE :
 Procedure File_FindBreak;

 UNIT...: ~Unit MOS_FIL~
 IN.....: /                                                                
 OUT....: /                                                                
 EXPLAIN: Break and stop the File_Find procedure when running.             
 SEE ALSO..: 
    ~File_Find~

:File_Find
%ͻ
%                            Procedure File_Find                            
%ͼ

 PROTOTYPE :
 Procedure File_Find(Source:String; Recurse:Boolean; FileDoer:TRecurseProc);

 UNIT...: ~Unit MOS_FIL~
 IN.....: Source (STRING) = First directory where will begin the search of 
                            the file + the mask                            
          Recurse (BOOLEAN) = Search in sub-directory also.                
          Filedoer (TRecurseProc) = Every time this procedure find a file  
                                   a procedure will be called : This proc  
                                   is pass in parameter, and you have to   
                                   write it.                               
                                   The type of this proc is :              
                  Type TRecurseProc = Procedure (x:PathStr);               
           At every file found, the proc filedoer will be called with      
           the name of the file for parameter.                             
 OUT....: /                                                                
 EXPLAIN: Search recursively in a directory.                               
 EXAMPLE: Procedure Show(X:PathStr);FAR;                                   
          Begin                                                            
          Writeln(X);                                                      
          End;                                                             
          File_Find('c:\*.*',True,Show);                                   
          File_Find('c:\tp7\*.pas',True,Show);                             
          File_Find('..\..\m?s*.*',False,Show);                            

:File_TargetFileName
%ͻ
%                       Function File_TargetFileName                        
%ͼ

 PROTOTYPE :
 Function File_TargetFileName(Source,Target,SourceFN:String):String;

 UNIT...: ~Unit MOS_FIL~
 IN.....: Source (STRING) = Source Path and Mask                           
          Target (STRING) = Target Path and Mask                           
          SourceFN (STRING) = Complete Source FileName                     
 OUT....: (STRING) = Complete Target FileName                              
 EXPLAIN: This function return a target filename.                          
          If you create an application witch works like this :             
          app source target (Example : Xcopy ...)                          
          And you have to process all the sources files, when you have     
          1 file name, this function return the target filename            
 EXAMPLE: File_TargetFileName('c:\2','d:\','c:\2\t.txt') ='d:\2\t.txt'     
          File_TargetFileName('c:\','d:\3','c:\2\t.txt') ='d:\3\2\t.txt'   

:File_TestExist
%ͻ
%                          Function File_TestExist                          
%ͼ

 PROTOTYPE :
 Function File_TestExist(Name:String):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: Name (STRING) = Path + Name of the file                          
 OUT....: (BOOLEAN) = TRUE if the file exist, else FALSE.                  
 EXPLAIN: Test if the file exist.                                          

:File_TestHeader
%ͻ
%                         Function File_TestHeader                          
%ͼ

 PROTOTYPE :
 Function File_TestHeader(FN:String;Header:String;Offset:Longint):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FN (STRING) = Path + Name of the File                            
          Header (STRING) = Caracteristic string of the header             
          Offset (LONGINT) = Position in Bytes of the header in the file   
 OUT....: (BOOLEAN) = TRUE if the header is OK.                            
 EXPLAIN: This function tests if a file is typed with the specified        
          format : If the string Header is found in the header of the      
          file return true, else FALSE.                                    
 EXAMPLE: Function TEST_WAV(FN:String);                                    
          Begin                                                            
          TEST_WAV:=File_TestHeader(FN,'RIFF',0);                          
          End;                                                             
 NB.....: TEST_GIF, TEST_BMP, TEST_WAV can be optimized with.              
          TEST_FLI perharps                                                

:File_GetSize
%ͻ
%                           Function File_GetSize                           
%ͼ

 PROTOTYPE :
 Function File_GetSize(Name:String):Longint;

 UNIT...: ~Unit MOS_FIL~
 IN.....: Name (STRING) = Name of the file.                                
 OUT....: (LONGINT) = Size of the file.                                    
 EXPLAIN: Return the size of the file if it exist.                         

:File_BuildNextName
%ͻ
%                        Function File_BuildNextName                        
%ͼ

 PROTOTYPE :
 Function File_BuildNextName(S:string):String;

 UNIT...: ~Unit MOS_FIL~
 IN.....: S (STRING) = Input File Name                                     
 OUT....: (STRING)   = OutPut File Name                                    
 EXPLAIN: We put in S a generic file name, and we get a file name witch    
          don't exist.                                                     
          Complete path name must be in S !!                               
 EXAMPLE: If we have this files on the HD :                                
          Image0.bmp, Image1.bmp                                           
          And we use File_BuildNextName('Image.bmp');                      
          The result will be Image2.bmp                                    
 CF.....: Screen Snapshot & Disk Swapping.                                 
 BUGS...: If the Name of the file have 8 letters...                        

:File_Erase
%ͻ
%                            Function File_Erase                            
%ͼ

 PROTOTYPE :
 Function File_Erase(Fn:String):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: Fn (STRING) = Path + Name of a file to delete                    
 OUT....: (BOOLEAN) = TRUE if no I/O error, else FALSE                     
 EXPLAIN: Erase, Delete a file.                                            
 EXAMPLE: File_Erase('Temp.dat');                                          
 NB.....: If the file doesn't exit return FALSE                            

:File_Replace
%ͻ
%                           Function File_Replace                           
%ͼ

 PROTOTYPE :
 Function File_Replace(FN1,FN2:String):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FN1 (STRING) = Path and FileName of the file to replace.         
          FN2 (STRING) = FileName of the file that have to replace FN1     
 OUT....: (BOOLEAN) = TRUE if operation completed, else FALSE              
 EXPLAIN: Replace a file by an other. (FN1 by FN2)                         
 EXAMPLE: File_Replace('toto.pas','toto.tmp');                             
 NB.....: Be careful : (FN1 will be replaced by FN2)                       

:File_Rename
%ͻ
%                           Function File_Rename                            
%ͼ

 PROTOTYPE :
 Function File_Rename(FN1,FN2:String):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FN1 (STRING) = Path + FileName of the file to rename.            
          FN2 (STRING) = New Path and fileName of the file.                
 OUT....: (BOOLEAN) = TRUE if operation completed, else FALSE              
 EXPLAIN: Rename a file.                                                   
 EXAMPLE: File_Rename('toto.pas',toto.bak');                               

:File_Split
%ͻ
%                           Procedure File_Split                            
%ͼ

 PROTOTYPE :
 Procedure File_Split(S:String;Var Path,Mask:String);

 UNIT...: ~Unit MOS_FIL~
 IN.....: S : (STRING) = Name (& Path) of the file to split or a mask file 
 OUT....: Path : (STRING) = Real path of the file                          
          Mask : (STRING) = Mask obtained                                  
 EXPLAIN: Splits a file name into its 2 components.                        
          File_Split is more powerful than FSplit look examples :          
 CF.....: FSplit from Dos Tp7 unit.                                        
 EXAMPLE: File_Split('')             = Default Path & '*.*'                
          File_Split('toto.pas')     = Default Path & 'toto.pas'           
          File_Split('c:\')          = 'C:\'        & '*.*'                
          File_Split('c:\dos')       = 'C:\DOS\'    & '*.*'                
          File_Split('c:\dos\*.pas') = 'C:\DOS\'    & '*.pas'              

:File_Copy
%ͻ
%                            Function File_Copy                             
%ͼ

 PROTOTYPE :
 Function File_Copy (SourceFile,TargetFile:String):Byte;

 UNIT...: ~Unit MOS_FIL~
 IN.....: SourceFile (STRING) = Path + Name of the source file.            
          TargetFile (STRING) = Path + Name of the target file.            
 OUT....: (BYTE) = Return codes :                                          
            0 successful                                                   
            1 source and target are the same                               
            2 cannot open source                                           
            3 unable to create target                                      
            4 error during copy                                            
 EXPLAIN: Copy a file.                                                     
 EXAMPLE: File_Copy('c:\Command.com','d:\toto.com');                       

:File_Comp
%ͻ
%                            Function File_Comp                             
%ͼ

 PROTOTYPE :
 Function File_Comp(SourceFile,TargetFile:String):Byte;

 UNIT...: ~Unit MOS_FIL~
 IN.....: SourceFile (STRING) = Path + Name of the source file.            
          TargetFile (STRING) = Path + Name of the target file.            
 OUT....: (BYTE) = Return code :                                           
            0 Successful : The files are the same                          
            1 The files are different                                      
            2 Cannot open source                                           
            3 Source and target have the same NameFiles                    
            4 Target doesn't exist                                         
            5 The size of the files are <> so the files are <>             
 EXPLAIN: Test if 2 files are identicals.                                  

:File_ClearBlankLines
%ͻ
%                      Procedure File_ClearBlankLines                       
%ͼ

 PROTOTYPE :
 Procedure File_ClearBlankLines(Source,Target:String);

 UNIT...: ~Unit MOS_FIL~
 IN.....: Source (STRING) = Path+Name of the file                          
          Target (STRING) = Path+Name of the file result.                  
 OUT....: /                                                                
 EXPLAIN: If there is more than 1 blank line don't copy the blank line     
          but copy all other lines...                                      

:File_GetLine
%ͻ
%                           Function File_GetLine                           
%ͼ

 PROTOTYPE :
 Function File_GetLine(FileName:String; Line:Longint):String;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FileName (STRING) = Path+Name of the file                        
          Line (LONGINT) = Line to get the string.                         
 OUT....: (STRING) = The string of the line.                               
 EXPLAIN: Get the string of a line from a file.                            
 SEE ALSO..: 
    ~Dsk_CoutLines~

:File_CountLines
%ͻ
%                         Function File_CountLines                          
%ͼ

 PROTOTYPE :
 Function File_CountLines(FileName:String):Longint;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FileName (STRING) = Path+Name of the file                        
 OUT....: (LONGINT) = Number of lines of the test file.                    
 EXPLAIN: Count the number of lines of a file.                             
 SEE ALSO..: 
    ~File_GetLine~

:File_AppendStr
%ͻ
%                          Function File_AppendStr                          
%ͼ

 PROTOTYPE :
 Function File_AppendStr(FN:String;S:String):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FN (STRING) = Path + Name of the file to process                 
          S  (STRING) = String to put on the end of the file               
 OUT....: (BOOLEAN) = TRUE if all is OK, else FALSE                        
 EXPLAIN: Put a string at the end of a text file. If the file don't exist  
          it will be created.                                              
 NB.....: The file must be a text file.                                    
 EXAMPLE: Writeln('Setup completed : ',File_AppendStr('AUTOEXEC.BAT',      
          'Set DPMIMEM = MAXMEM 2048'));                                   

:File_GetLongString
%ͻ
%                        Function File_GetLongString                        
%ͼ

 PROTOTYPE :
 Function File_GetLongString(FN:String):String;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FN (STRING) = Name of the file where the search will begin       
 OUT....: (STRING) = The longest string of the text file.                  
 EXPLAIN: Return the last longest string of a file.                        

:File_Create
%ͻ
%                           Function File_Create                            
%ͼ

 PROTOTYPE :
 Function File_Create(FName:String):Boolean;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FName (STRING) = Name of the file to create                      
 OUT....: (BOOLEAN) = TRUE if the file is created, else FALSE              
 EXPLAIN: Create an empty text file.                                       

:File_TestString
%ͻ
%                         Function File_TestString                          
%ͼ

 PROTOTYPE :
 Function File_TestString(FN,St:String; Mode:Integer):Longint;

 UNIT...: ~Unit MOS_FIL~
 IN.....: FN (STRING) = Path + File name                                   
          St (STRING) = String to test if is in file !!!                   
          Mode (BYTE) = 0 = Test the whole file line is equal.             
                        1 = Test if the string is contained in line.       
 OUT....: (LONGINT) = Line number where the string found.                  
          Return 0 is no string found.                                     
 EXPLAIN: Test if a string is or not in a text file !!                     

:File_XAttrib
%ͻ
%                          Procedure File_XAttrib                           
%ͼ

 PROTOTYPE :
 Procedure File_XAttrib(Source:String;Attr:Word);

 UNIT...: ~Unit MOS_FIL~
 IN.....: Source (STRING) = Directory where to begin the attrib            
          Attr (WORD) = File Attributes                                    
 OUT....: /                                                                
 EXPLAIN: Set to all files in the source directory the attributes.         

:Card_DefineBack
%ͻ
%                         Function Card_DefineBack                          
%ͼ

 PROTOTYPE :
 Function Card_DefineBack ( Px,Py:Integer; FName:String):String;

 UNIT...: ~Unit MOS_CAR~
 IN.....: Px,Py (INTEGER) = X,Y position for the Requester.                
 OUT....: (STRING) = Return the filename to use as the card back.          
 EXPLAIN: Call a requester to select an image for the card back            
          and return the selected image filename.                          

:Card_Define
%ͻ
%                           Procedure Card_Define                           
%ͼ

 PROTOTYPE :
 Procedure Card_Define (Var C:TCards; Num,Px,Py:Integer; Visible,Movable,
           Recto:Boolean);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
          Px,Py (INTEGER) = X,Y Position for the card.                     
          Visible (BOOLEAN) = TRUE if the card is visible.                 
          Movable (BOOLEAN) = TRUE if the card is movable.                 
          Recto (BOOLEAN) = TRUE if the card side displayed is the Recto.  
 OUT....: /                                                                
 EXPLAIN: Define a card with all the required parameters.                  
 SEE ALSO..: 
    ~Card_SetRecto~
    ~Card_SetIdent~
    ~Card_Position~
    ~Card_SetMovable~

:Card_GetFileName
%ͻ
%                         Function Card_GetFileName                         
%ͼ

 PROTOTYPE :
 Function Card_GetFileName ( C:TCards; Num:Integer):String;

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: (STRING) = Return the card filename corresponding to "Num".      
 EXPLAIN: Return the filename corresponding to a required card.            

:Card_GetIdent
%ͻ
%                          Function Card_GetIdent                           
%ͼ

 PROTOTYPE :
 Function Card_GetIdent ( C:TCards; Num:Integer):String;

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: (STRING) = Return the "Ident" field for a card.                  
 EXPLAIN: Get a card parameter.                                            
 SEE ALSO..: 
    ~Card_SetIdent~

:Card_GetRecto
%ͻ
%                          Function Card_GetRecto                           
%ͼ

 PROTOTYPE :
 Function Card_GetRecto ( C:TCards; Num:Integer):Boolean;

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: (BOOLEAN) = Return TRUE if the card if on the Recto.             
 EXPLAIN: Get a card parameter.                                            
 SEE ALSO..: 
    ~Card_SetRecto~

:Card_Mix
%ͻ
%                            Procedure Card_Mix                             
%ͼ

 PROTOTYPE :
 Procedure Card_Mix (Var C:TCards);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
 OUT....: /                                                                
 EXPLAIN: Mix the card set.                                                
 SEE ALSO..: 
    ~Card_NewGame~

:Card_NewGame
%ͻ
%                          Procedure Card_NewGame                           
%ͼ

 PROTOTYPE :
 Procedure Card_NewGame (Var C:TCards);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
 OUT....: /                                                                
 EXPLAIN: Define a new card set using current parameters.                  
          Define each card using the Card_Define function.                 
 SEE ALSO..: 
    ~Card_Mix~

:Card_SetMaximum
%ͻ
%                         Procedure Card_SetMaximum                         
%ͼ

 PROTOTYPE :
 Procedure Card_SetMaximum (Var C:TCards; Max:Integer);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Max (INTEGER) = Define the maximum cards quantity.               
             Authorised values are 32 and 52.                              
 OUT....: /                                                                
 EXPLAIN: Modify a card parameter.                                         

:Card_SetRecto
%ͻ
%                          Procedure Card_SetRecto                          
%ͼ

 PROTOTYPE :
 Procedure Card_SetRecto (Var C:TCards; Num:Integer; Recto:Boolean);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
          Recto (BOOLEAN) = Define the card side to show (TRUE = Recto).   
 OUT....: /                                                                
 EXPLAIN: Modify a card parameter.                                         
 SEE ALSO..: 
    ~Card_GetRecto~

:Card_SetIdent
%ͻ
%                          Procedure Card_SetIdent                          
%ͼ

 PROTOTYPE :
 Procedure Card_SetIdent (Var C:TCards; Num:Integer; Ident:String);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
          Ident (STRING) = Set a new value for the "Ident" field card.     
 OUT....: /                                                                
 EXPLAIN: Modify a card parameter.                                         
 SEE ALSO..: 
    ~Card_GetIdent~

:Card_SetPosition
%ͻ
%                        Procedure Card_SetPosition                         
%ͼ

 PROTOTYPE :
 Procedure Card_SetPosition (Var C:TCards; Num,Px,Py:Integer);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
          Px,Py (INTEGER) = Define the card X,Y position.                  
 OUT....: /                                                                
 EXPLAIN: Modify a card parameter.                                         
 SEE ALSO..: 
    ~Card_Define~

:Card_SetMovable
%ͻ
%                         Procedure Card_SetMovable                         
%ͼ

 PROTOTYPE :
 Procedure Card_SetMovable (Var C:TCards; Num:Integer; Movable:Boolean);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
          Movable (BOOLEAN) = TRUE if the card needs to be movable.        
 OUT....: /                                                                
 EXPLAIN: Modify a card parameter.                                         
 SEE ALSO..: 
    ~Card_Define~

:Card_SetHide
%ͻ
%                          Procedure Card_SetHide                           
%ͼ

 PROTOTYPE :
 Procedure Card_SetHide (Var C:TCards; Num:Integer; State:Boolean);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
          State (BOOLEAN) = TRUE if the card needs to be hide.             
 OUT....: /                                                                
 EXPLAIN: Modify a card parameter and display a gain the card.             
 SEE ALSO..: 
    ~Card_Define~

:Card_Hide
%ͻ
%                            Procedure Card_Hide                            
%ͼ

 PROTOTYPE :
 Procedure Card_Hide ( C:TCards; Num:Integer);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: /                                                                
 EXPLAIN: Hide a card.                                                     
 SEE ALSO..: 
    ~Card_Toggle~
    ~Card_Display~

:Card_Display
%ͻ
%                          Procedure Card_Display                           
%ͼ

 PROTOTYPE :
 Procedure Card_Display ( C:TCards; Num:Integer);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: /                                                                
 EXPLAIN: Display a card using self parameters.                            
 SEE ALSO..: 
    ~Card_Toggle~
    ~Card_Hide~

:Card_Toggle
%ͻ
%                           Procedure Card_Toggle                           
%ͼ

 PROTOTYPE :
 Procedure Card_Toggle ( C:TCards; Num:Integer);

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: /                                                                
 EXPLAIN: Display a card and toggle it by XOR mode the card surface.       
          Allow you to do like if you make a card selection.               
 SEE ALSO..: 
    ~Card_Display~
    ~Card_Hide~

:Card_TestMouseOver
%ͻ
%                        Function Card_TestMouseOver                        
%ͼ

 PROTOTYPE :
 Function Card_TestMouseOver ( C:TCards; Num:Integer):Boolean;

 UNIT...: ~Unit MOS_CAR~
 IN.....: C (TCard) = Pointer to the TCard structure.                      
          Num (INTEGER) = The card number (1 to 52).                       
 OUT....: (BOOLEAN) = TRUE if the mouse is over the card surface.          
 EXPLAIN: Test if the mouse is over a card and return result.              


:Incp
%ͻ
%                              Procedure Incp                               
%ͼ

 PROTOTYPE :
 Procedure Incp(Var P:Pointer;W:Word);

 UNIT...: ~Unit MOS_MEM~
 IN.....: P (POINTER) = Pointer to increment                               
          W (WORD) = Quantity of bytes to increment P                      
 OUT....: P (POINTER) = P+W bytes.                                         
 EXPLAIN: Increment the pointer P of W bytes.                              
 EXAMPLE: P='00FA:0010';Incp(P,$100);Result : P='00FA:0110'.               
 BUGS...: If P+W>FFFF:FFFF ...                                             

:Decp
%ͻ
%                              Procedure Decp                               
%ͼ

 PROTOTYPE :
 Procedure Decp(Var P:Pointer;W:Word);

 UNIT...: ~Unit MOS_MEM~
 IN.....: P (POINTER) = Pointer to decrement                               
          W (WORD) = Quantity of bytes to decrement P                      
 OUT....: P (POINTER) = P+W bytes.                                         
 EXPLAIN: Decrement the pointer P of W bytes.                              
 EXAMPLE: P='00FA:0110';Decp(P,$100);Result : P='00FA:0010'.               
 BUGS...: If P-W<0000:0000 ...                                             


