home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 17 / CD_ASCQ_17_101194.iso / dos / prg / mos / docs / new_proc.txt < prev    next >
Text File  |  1994-09-11  |  18KB  |  307 lines
  1.  
  2.     Voici la liste des nouvelles fonctions et procédures définies par MOS.
  3.  
  4. {╔═══════════════════════════════════════════════════════════════════════════╗
  5.  ║                               UNITES TEXTES                               ║
  6.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  7.  
  8. {*----------------------------- Unité ZUUL_ASM -----------------------------*}
  9.  
  10. Procedure PRINT_SCREEN;                        {*Print Contenue Ecran*}
  11. Procedure WARM_REBOOT;                         {*Reboot Propre à Chaud*}
  12. Procedure COLD_REBOOT;                         {*Reboot Propre à Froid*}
  13. Procedure PURGE_BUFFER_CLAVIER;                {*Vide Buffer Clavier*}
  14. Procedure WAIT_VBL;                            {*Wait Synchronisation*}
  15. Procedure LOCK_CTRLB;                          {*Detourne CTRL Break*}
  16. Procedure UNLOCK_CTRLB;                        {*Restore CTRL Break*}
  17. Procedure LOCK_CRITICAL;                       {*Detourne Critical Errors*}
  18. Procedure UNLOCK_CRITICAL;                     {*Restore Critical Errors*}
  19. Function  GET_DOS_VERSION:String;              {*Version du DOS*}
  20. Function  GET_MOUSE_VERSION:String;            {*Version Gestionnaire Souris*}
  21. Function  GET_MOUSE_TYPE:String;               {*Type de Souris*}
  22. Function  GET_PROCESSOR:Byte;                  {*Renvoi le Type de Processor*}
  23. Function  GET_COPRO:Byte;                      {*Renvoi le Type de CoPro*}
  24. Function  GET_SPEED:String;                    {*Renvoi la Vitesse du CPU*}
  25. Procedure SET_TASK(Status:Boolean);            {*Enable/Disable Multitasking*}
  26. Procedure PROTECTED_MODE;                      {*Passe en Mode Protégé*}
  27. Procedure ENDING_PROGRAM;                      {*Termine un Prog et Ferme tout*}
  28. Procedure SCREEN(Status:Boolean);              {*Vidéo Screen On/Off*}
  29.  
  30. Procedure SETHORLOGETIMER(Freq:Real);          {*Set Frequence Horloge*}
  31. Procedure SET_TIMER(Freq:Real);                {*Init & Begin Timer*}
  32. Procedure RESTORE_TIMER;                       {*Restore Old Normal Timer*}
  33.  
  34. Function  PEEK(S,O:Word):Byte;                 {*Equivalent Basic du Peek*}
  35. Procedure PARK;                                {*Park Têtes Lecteures C et D*}
  36. Procedure EXG(Var A,B:Integer);                {*Echange Both Values*}
  37. Procedure INIT_PRINTER;                        {*Initilaise Printer*}
  38.  
  39. Procedure INIT_ASM;                            {*Initialise All for Hardware*}
  40. Procedure DONE_ASM;                            {*Restore All for Hardware*}
  41.  
  42. {*----------------------------- Unité ZUUL_COL -----------------------------*}
  43.  
  44. Procedure TC(C:Integer);                       {*Change Text Color*}
  45. Procedure BGC(C:Integer);                      {*Change Background Color*}
  46. Procedure EXTENDEDCOLS;                        {*Etend les Couleurs*}
  47. Procedure NORMALCOLS;                          {*Restreint les Couleurs*}
  48.  
  49. {*----------------------------- Unité ZUUL_DIR -----------------------------*}
  50.  
  51. Function  TEST_DEVICE(Dev:Byte):Boolean;       {*Teste la Présence d'un Device*}
  52. Procedure GIVEDIR(PX,PY:Integer;Var Si:LongInt; Var DirSel,FilSel:String);{*File Requester*}
  53.  
  54. {*----------------------------- Unité ZUUL_GAD -----------------------------*}
  55.  
  56. Procedure BUTTON(X,Y,Cp,Cu,Cg:Word; Var GadBut:But; Name:String);
  57. Function  GADMSG(Var GadBut:But; B:Word):Boolean; {*Test T_Button Msg*}
  58.  
  59. {*----------------------------- Unité ZUUL_MEN -----------------------------*}
  60.  
  61. Procedure MENU_BAR_DISP(Var TbMem:Men_Dat);
  62. Procedure GIVEMENU(FreeM,FreeP,HelpL:Boolean; Var MS,IS:Integer);
  63.  
  64. {*----------------------------- Unité ZUUL_MSE -----------------------------*}
  65.  
  66. Function  INITMOUSE:Bool;                         {Positionne Souris au Centre Screen}
  67. Procedure SHOWMOUSE;                              {Affiche la Souris}
  68. Procedure HIDEMOUSE;                              {Hide la Souris}
  69. Function  BOXMOUSET(X1,Y1,X2,Y2,B:Word):Bool;     {TXT | Test if Mouse is in Box}
  70. Procedure GETMOUSET(Var X,Y:Word;Var G,M,D:Bool); {TXT | OUT: X/Y = Coord Mouse. G/M/D = States Buttons}
  71. Procedure PUTMOUSET(X,Y:Word);                    {TXT | Put Mouse on X,Y}
  72. Procedure LIMITMOUSET(X1,Y1,X2,Y2:Word);          {TXT | Limit Mouse on Box (X1,Y1,X2,Y2)}
  73. Procedure CURSON;                                 {*Deplanque le Curseur TXT*}
  74. Procedure CURSOFF;                                {*Planque le Curseur TXT*}
  75. Procedure DEFCURSOR(H,B:Word);                    {*Definit le Curseur*}
  76. Procedure MASKCURSOR(Maskand,Maskxor:Word);       {*Mask Cursor*}
  77.  
  78. {*----------------------------- Unité ZUUL_REQ -----------------------------*}
  79.  
  80. Procedure EZ_REQUEST(TXT,GAD:String; Var NUM:ShortInt; Esc:Boolean);
  81. Procedure ST_REQUEST(TXT,GAD:String; Var REP:STring; Var NUM:ShortInt; LEN:Word; Esc:Boolean);
  82. Procedure CO_REQUEST(X,Y,Cet,Len:Word; Var Cin:String);   {*Command Line*}
  83. Procedure VA_REQUEST(TXT,GAD:String; BMIN,BMAX:Longint; Var NUM:ShortInt; Var VAI:LongInt; Esc:Boolean);
  84.  
  85. {*----------------------------- Unité ZUUL_SWA -----------------------------*}
  86.  
  87. Procedure SWAPHIDE(X1,Y1,X2,Y2:Byte; Var SW:Savewin);
  88. Procedure SWAPSHOW(X1,Y1:Byte; SW:Savewin);
  89. Procedure SWAP_SHADOW(X1,Y1,X2,Y2:Byte);
  90. Procedure GOPAGE(X:Byte);                       {*Definit la Page de Travail*}
  91. Procedure COPYPAGE(Source,Target:Byte);         {*Copy une page/une autre*}
  92. Function  GETACTIVEPAGE:Byte;                   {*Renvois le Numéro de la Page Active*}
  93. Procedure SAVESCREEN(Page:Byte);                {*Save Screen on Memory*}
  94. Procedure LOADSCREEN(Page:Byte);                {*Set Mem Screen on Page*}
  95.  
  96. {*----------------------------- Unité ZUUL_TOO -----------------------------*}
  97.  
  98. Procedure CLS3(X1,Y1,Y2,LEN,T:Integer);   {*Clear Screen Type 3*}
  99. Procedure BEEP;                           {*Produit sound of PVL Sound BB/AG*}
  100. Procedure BOX(X1,Y1,X2,Y2:Integer;B1,B2,B3:Boolean);
  101.  
  102. {*----------------------------- Unité ZUUL_TXT -----------------------------*}
  103.  
  104. Procedure DISP(CH:String);                {*Print String With Beep*}
  105. Procedure DISPLN(CH:String);              {*Print String With Beep & CR*}
  106. Procedure WAIT;                           {*Attend une Touche Pressée*}
  107. Function  UPPER(SUP:String):String;       {*Passe en Majuscule*}
  108. Function  LOWER(SUP:String):String;       {*Passe en Minuscules*}
  109. Function  MIDDER(SUP:String):String;      {*Minuscules & 1ere Lette en Maj*}
  110. Function  CRYPT(Str1,Str2,Ph1:String):String;{*Cryp & Uncrypt String*}
  111. Function  GETCHAR(Var Ac,Sc:Byte):Boolean;{*Teste sans Bloquer le Clavier*}
  112. Function  CHAR_TO_HEX(H:Char):Byte;       {*Convertit Char -> Byte*}
  113. Function  WORD_TO_STRING(D:Word):ShortString;{*Convertit Word -> String*}
  114. Function  SPECIAL_KEY(Num:Byte):Boolean;  {*Teste Touche Spéciale Clavier*}
  115.  
  116. {╔═══════════════════════════════════════════════════════════════════════════╗
  117.  ║                             UNITES GRAPHIQUES                             ║
  118.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  119.  
  120. {*----------------------------- Unité ZUUL_ASM -----------------------------*}
  121.  
  122. Procedure PRINT_SCREEN;                        {*Print Contenue Ecran*}
  123. Procedure WARM_REBOOT;                         {*Reboot Propre à Chaud*}
  124. Procedure COLD_REBOOT;                         {*Reboot Propre à Froid*}
  125. Procedure PURGE_BUFFER_CLAVIER;                {*Vide Buffer Clavier*}
  126. Procedure WAIT_VBL;                            {*Wait Synchronisation*}
  127. Procedure LOCK_CTRLB;                          {*Detourne CTRL Break*}
  128. Procedure UNLOCK_CTRLB;                        {*Restore CTRL Break*}
  129. Procedure LOCK_CRITICAL;                       {*Detourne Critical Errors*}
  130. Procedure UNLOCK_CRITICAL;                     {*Restore Critical Errors*}
  131. Function  GET_DOS_VERSION:String;              {*Version du DOS*}
  132. Function  GET_MOUSE_VERSION:String;            {*Version Gestionnaire Souris*}
  133. Function  GET_MOUSE_TYPE:String;               {*Type de Souris*}
  134. Function  GET_PROCESSOR:Byte;                  {*Renvoi le Type de Processor*}
  135. Function  GET_COPRO:Byte;                      {*Renvoi le Type de CoPro*}
  136. Function  GET_SPEED:String;                    {*Renvoi la Vitesse du CPU*}
  137. Procedure SET_TASK(Status:Boolean);            {*Enable/Disable Multitasking*}
  138. Procedure PROTECTED_MODE;                      {*Passe en Mode Protégé*}
  139. Procedure ENDING_PROGRAM;                      {*Termine un Prog et Ferme tout*}
  140. Procedure SCREEN(Status:Boolean);              {*Vidéo Screen On/Off*}
  141.  
  142. Procedure SETHORLOGETIMER(Freq:Real);          {*Set Frequence Horloge*}
  143. Procedure SET_TIMER(Freq:Real);                {*Init & Begin Timer*}
  144. Procedure RESTORE_TIMER;                       {*Restore Old Normal Timer*}
  145.  
  146. Function  PEEK(S,O:Word):Byte;                 {*Equivalent Basic du Peek*}
  147. Procedure PARK;                                {*Park Têtes Lecteures C et D*}
  148. Procedure EXG(Var A,B:Integer);                {*Echange Both Values*}
  149. Procedure INIT_PRINTER;                        {*Initilaise Printer*}
  150.  
  151. Procedure INIT_ASM;                            {*Initialise All for Hardware*}
  152. Procedure DONE_ASM;                            {*Restore All for Hardware*}
  153.  
  154. {*----------------------------- Unité ZUUL_BAS -----------------------------*}
  155.  
  156. Function INITGFX:Integer;                      {*Initialisation Graphique*}
  157.  
  158. {*----------------------------- Unité ZUUL_COL -----------------------------*}
  159.  
  160. Procedure GetRGBPalette(C:Byte;Var R,G,B:Byte);{*Recupere Valeurs RGB Couleur*}
  161. Procedure DEFINE_PALETTE;                      {*Définition de la Palette*}
  162.  
  163. {*----------------------------- Unité ZUUL_DIR -----------------------------*}
  164.  
  165. Function  TEST_DEVICE(Dev:Byte):Boolean;       {*Teste la Présence d'un Device*}
  166. Function  GET_DEVICE_NAME(Root:String):String; {*Renvois le Nom du Volume*}
  167. Procedure GET_FILEDIR(X1,Y1,Sv:Integer; Name,OkBut,Mask:String; Filordir:Byte;
  168.                    Var DirSel,FilSel:String; Var Size:LongInt);{*File Requester*}
  169.  
  170. {*----------------------------- Unité ZUUL_GAD -----------------------------*}
  171.  
  172. Procedure DEFINE_GADGETS;                      {*Definit Gadgets Sp*}
  173. Procedure KILL_GADGETS;                        {*Libere Mem des Gadgets*}
  174. Procedure INIT_SCREEN;                         {*Init Screen Gfx*}
  175. Procedure DONE_SCREEN;                         {*Restore Normal Screen*}
  176.  
  177. Procedure BUTTONG(X,Y,Size:Integer; Lock:Boolean; Var But:ButG; St:String);{*Draw & Define*}
  178. Procedure RADIO_BOX(X,Y,Style:Integer; Status:Boolean; Var R:Rad);
  179. Procedure CYCLER_BUT(X,Y,Size,Num:Integer; Var But:ButG; St:String);
  180. Procedure SLIDER(X1,Y1,X2,Y2,Qtt,Aff,Typ:Integer; GDep:Boolean; Var S:Slide; Psl:Integer);
  181.  
  182. Procedure DRAW_RADIO_BOX(R:Rad);               {*Redraw Gadgets*}
  183. Procedure DRAW_BUTTONG(B:ButG);
  184. Procedure DRAW_SLIDER(Var S:SLide);
  185.  
  186. Function  GETMSG_BUT(Var B:ButG; M:Word):Boolean;{*Get Messages*}
  187. Function  GETMSG_RADIO(Var R:Rad; M:Word):Boolean;
  188. Function  GETMSG_SLIDER(Var S:Slide; M:Word):Boolean;
  189.  
  190. {*----------------------------- Unité ZUUL_MSE -----------------------------*}
  191.  
  192. Function  INITMOUSE:Bool;                         {Positionne Souris au Centre Screen}
  193. Procedure SHOWMOUSE;                              {Affiche la Souris}
  194. Procedure HIDEMOUSE;                              {Hide la Souris}
  195. Function  BOXMOUSEG(X1,Y1,X2,Y2,B:Word):Bool;     {GFX | Test if Mouse is in Box}
  196. Procedure GETMOUSEG(Var X,Y:Word;Var G,M,D:Bool); {GFX | OUT: X/Y = Coord Mouse. G/M/D = States Buttons}
  197. Procedure PUTMOUSEG(X,Y:Word);                    {GFX | Put Mouse on X,Y}
  198. Procedure LIMITMOUSEG(X1,Y1,X2,Y2:Word);          {GFX | Limit Mouse on Box (X1,Y1,X2,Y2)}
  199. Procedure SPEEDMOUSE(X,Y:Integer);                {Speed Mouse. Mickeys/Pixels}
  200. Procedure INIT_MOUSE;                             {*Initialise Mouse for Gfx*}
  201. Procedure DONE_MOUSE;                             {*Reinstalle Normal Mouse*}
  202. Procedure MOUSE_BLANKER;                          {*Gère le Mouse Blanker*}
  203. Procedure SET_POINTER(Style:Byte);                {*Redefinit Pointeur MSE*}
  204.  
  205. Function  CLICK_MOUSE(Num:Integer):Boolean;       {Teste si la Souris est Cliquée}
  206. Function  DOUBLE_CLICK:Boolean;                   {Teste Double Click Souris}
  207. Procedure DEF_DOUBLE_CLICK(T:Integer);            {Definition Double Click}
  208. Procedure DEF_MOUSE_DELAY(T:Integer);             {Definition Mouse Delay}
  209. Function  MOUSE_DELAY:Boolean;                    {True=Mouse Delay Passé}
  210.  
  211. Procedure INIT_CURSOR(Style,Blink:Integer; Var Loc:LocG);{*Positionne Curseur Graphique*}
  212. Procedure LOCATE(X,Y:Integer; Var Loc:LocG);
  213. Procedure CURSONG(Var Loc:LocG);                  {*Affiche Curseur GFX*}
  214. Procedure CURSOFFG(Var Loc:LocG);                 {*Cache le Curseur GFX*}
  215.  
  216. {*----------------------------- Unité ZUUL_REQ -----------------------------*}
  217.  
  218. Procedure MAIN_TASK;                                      {*Gère All Main*}
  219. Procedure EZ_REQUESTG(Name,TXT,GAD:String; Var NUM:Integer);{*EZ Requester*}
  220. Procedure STRING_REQUESTG(Name,TXT,GAD:String; NbCar,Size:Integer; Var Cin:String; Var NUM:Integer);
  221. Procedure PALETTE_REQUESTG(X1,Y1:Integer; Name:String; Var NUM:Integer);{*Gère Couleurs*}
  222. Procedure MEMORY_REQUESTG(X1,Y1:Integer; Name:String);    {*Aff Qtt Mémoire*}
  223. Procedure PROGRESS_REQUESTG(Name,Explain:String; Val,CoB:Integer; Var P:TProgress);
  224. Procedure HARDWARE_REQUESTG(X1,Y1:Integer; Name:String);  {*Display Hardware*}
  225. Procedure SYSTEM_REQUESTG(X1,Y1:Integer; Name:String);    {*Systeme MOS Config*}
  226. Function  CO_REQUESTG(Var C:TCoReq; Var Cin:String):Boolean;{*Command Requester*}
  227. Procedure DRAW_CO_REQUESTG(X,Y,Siz:Word; Len,CoB,Sty:Byte;{*Affiche C_Request*}
  228.                       Var C:TCoReq; Var Cin:String);
  229.  
  230. {*----------------------------- Unité ZUUL_SWA -----------------------------*}
  231.  
  232. Type TSWAP = Object
  233.      IMG1:Pointer;                       {*GETIMAGE Variable*}
  234.      IMG2:Pointer;
  235.      Size1,Size2:Word;
  236.      X,Y,L,H:Word;                       {*Coordonnées de Travail*}
  237.      CONSTRUCTOR INIT;
  238.      DESTRUCTOR  STOP;
  239.      PROCEDURE   SAVE(DebX,DebY,Hauteur,Longueur:Word);
  240.      PROCEDURE   LOAD(DebX,DebY:Word);
  241.      PROCEDURE   SWAP;                   {*Inverse les pages de TRAVAIL*}
  242.      End;
  243.  
  244. Function  GETACTIVEPAGE:Byte;            {*Renvois le Numéro de la Page Active*}
  245.  
  246. {*----------------------------- Unité ZUUL_TOO -----------------------------*}
  247.  
  248. Procedure BEEP;                          {*Produit sound of PVL Sound BB/AG*}
  249. Procedure BEVEL(X1,Y1,X2,Y2,Style,Co:Integer; Cave,Fill:Boolean);{*Affiche un Box en Relief*}
  250. Procedure STRING_BOX(X1,Y1,X2,Y2,C1,C2:Integer; Style:Boolean);{*Box Spécial pour String*}
  251. Function  LIGHT_BOX(Var LB:LightB; M:Word):Boolean;{*Draw Box Clicking Mouse*}
  252.  
  253. {*----------------------------- Unité ZUUL_TXT -----------------------------*}
  254.  
  255. Procedure DISPG(X,Y,C:Integer; St:String);{*Display Texte*}
  256. Procedure WAIT;                           {*Attend une Touche Pressée*}
  257. Function  UPPER(SUP:String):String;       {*Passe en Majuscule*}
  258. Function  LOWER(SUP:String):String;       {*Passe en Minuscules*}
  259. Function  MIDDER(SUP:String):String;      {*Minuscules & 1ere Lette en Maj*}
  260. Function  CRYPT(Str1,Str2,Ph1:String):String;{*Cryp & Uncrypt String*}
  261. Function  GETCHAR(Var Ac,Sc:Byte):Boolean;{*Teste sans Bloquer le Clavier*}
  262. Function  CHAR_TO_HEX(H:Char):Byte;       {*Convertit Char -> Byte*}
  263. Function  WORD_TO_STRING(D:Word):ShortString;{*Convertit Word -> String*}
  264. Function  SPECIAL_KEY(Num:Byte):Boolean;  {*Teste Touche Spéciale Clavier*}
  265.  
  266. {*----------------------------- Unité ZUUL_WIN -----------------------------*}
  267.  
  268. Procedure INIT_WINDOW(X1,Y1,X2,Y2:Integer; IDCMP:Word; Name:String; Var W:Win); {*Définit la Fenêtre*}
  269. Procedure SUP_WINDOW(Xu,Yu,Xv,Yv,XMin,YMin,XMax,YMax,BarSld,Coul:Integer; IDRES:Word; Var W:Win);{*Définitions Sup*}
  270. Procedure KILL_WINDOW(Var W:Win);                  {*Détruit la Fenêtre*}
  271. Procedure DRAW_WINDOW(Var W:Win);                  {*Redraw Window*}
  272. Function  ACTIVE_WINDOW(Var W:Win):Integer;        {*Gere Activ + Gadgets*}
  273. Function  MOVE_WINDOW(Var W:Win):Boolean;          {*Déplacement Window*}
  274. Function  BOXE_WINDOW(W1,W2:Win):Boolean;          {*Test Intersection 2 Box*}
  275. Procedure TASK_WINDOW(Var W:Win);                  {*Gere Multifenetrage*}
  276. Procedure CLIP_WINDOW(Clip:Boolean; Var W:Win);    {*Clipping Window*}
  277. Procedure ZOOM_WINDOW(Mode:Boolean; Var W:Win);    {*Comme Zoom Window v1.2*}
  278. Procedure IDCMP_WINDOW(IDCMP:Word; Var W:Win);     {*Change IDCMP Fenêtre*}
  279. Procedure IDRES_WINDOW(IDRES:Word; Var W:Win);     {*Change IDRES Fenêtre*}
  280. Procedure CLEAR_WINDOW(Var W:Win);                 {*Clear Window = CLS*}
  281. Procedure RENAME_WINDOW(NewName:String; Var W:Win);{*Rename Window Title*}
  282. Function  WINDOW_READY(Var W:Win):Boolean;         {*Teste si Fenêtre Prête*}
  283.  
  284. {*----------------------------- Unité ZUUL_XMS -----------------------------*}
  285.  
  286. Function  XMSDriver:Boolean;    {*XMS Driver Installed ?*}
  287. Function  XMSControlAdr:Pointer;{*Returns Pointer to the XMS Controller*}
  288. Function  XMSVer:Word;          {*Version of the XMS Driver*}
  289. Function  XMSRev:Word;          {*Returns XMS Revision Number*}
  290. Function  XMSGetFreeMem:Word;   {*Total XMS Memory Free*}
  291. Function  XMSGetLargeBlock:Word;{*Size of the Largest Free XMS Block*}
  292. Function  XMSGetMem(Blocks:Word):Word;{*Allocate XMS for Program use*}
  293. Procedure XMSFreeMem(Handle:Word);{*Free Previously Allocated XMS Memory*}
  294. Procedure XMSMoveblock(Var Movstruct:XMSMovStruct);{*Move Memory Blocks Around in XMS Memory*}
  295. Procedure XMSLockBlock(Handle:Word);{*Lock an XMS block*}
  296. Procedure XMSUnLockBlock(Handle:Word);{*Unlock a Previously Locked XMS Block*}
  297. Procedure XMSReallocate(Handle,NewSize:Word);{*Reallocate and XMS Block*}
  298. Function  HMAExists:Boolean;    {*Returns Whether or not HMA Exists*}
  299. Procedure HMARequest(RequestType:Word);{*Attempt to Reserve the 64k HMA Area for the Caller*}
  300. Procedure HMARelease;           {*Release Previously Allocated HMA*}
  301. Procedure GlobaleEnableA20;     {*Enable the A20 Line. Must have HMA*}
  302. Procedure GlobaleDisableA20;    {*Disable the A20 Line. On Some Systems*}
  303. Procedure LocalEnableA20;       {*Enable the A20 Line for current Program*}
  304. Procedure LocalDisableA20;      {*Locally Disable the A20 Line*}
  305. Function  QueryA20:Boolean;     {*Test whether the A20 is Physically Enabled or not*}
  306. Function  PtrToLong(P:Pointer):Longint;{*Convert a Pointer to a 32 Bit Number*}
  307.