home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 17 / CD_ASCQ_17_101194.iso / dos / prg / mos / exemples / soft / ds_lib.pas next >
Pascal/Delphi Source File  |  1994-08-31  |  107KB  |  2,585 lines
  1. {╔═══════════════════════════════════════════════════════════════════════════╗
  2.  ║                         - DISK SPEED VERSION 1.0 -                        ║
  3.  ╠═══════════════════════════════════════════════════════════════════════════╣
  4.  ║                            - UNITE PRINCIPALE -                           ║
  5.  ╠═══════════════════════════════════════════════════════════════════════════╣
  6.  ║ Coded by Zuul alias Cheveau Frédéric.                                     ║
  7.  ║ Programmé à HTS sur Turbo Pascal v7.00.                                   ║
  8.  ║ Contact me on 36.14 RTEL1 - Bal "BouFFtou".                               ║
  9.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  10.  
  11. UNIT DS_LIB;                            {*Nom de l'Unité*}
  12.  
  13. INTERFACE
  14.  
  15. USES ZUUL_BAS,                          {*Unitées Nécessaires*}
  16.      ZUUL_ASM,
  17.      ZUUL_COL,
  18.      ZUUL_TOO,
  19.      ZUUL_MSE,
  20.      ZUUL_TXT,
  21.      ZUUL_GAD,
  22.      ZUUL_DIR,
  23.      ZUUL_REQ,
  24.      ZUUL_WIN,
  25.      Crt,
  26.      Graph;
  27.  
  28. CONST Max_Mod=6;                        {*Nombre Maximum de Modules*}
  29.       Max_Pts=500;                      {*Nombre Maximum de Points Gfx*}
  30.  
  31. TYPE TWrite   =Record           {====== STRUCTURE MODULES ======}
  32.      Name     :String;                  {*Nom ASCII du Module*}
  33.      FName    :String[12];              {*Nom du Fichier EXE du Module*}
  34.      FPath    :String[64];              {*Chemin du Fichier Module*}
  35.      Fragment :String[12];              {*Fragmenté ou Linéaire*}
  36.      Length   :Longint;                 {*Taille du Fichier à Ecrire*}
  37.      Buffer   :Longint;                 {*Taille du Buffer d'écriture*}
  38.      System   :String[32];              {*Systeme Utilisé (DOS/BIOS...)*}
  39.      Algo     :String[32];              {*Methode Utilisé (Commande Write)*}
  40.  
  41.      StatusMod:String[12];              {*Internal ou External*}
  42.      Number   :Byte;                    {*Numéro d'Ordre du Module*}
  43.      Time     :Longint;                 {*Temps en Millisecondes du Write*}
  44.      Rate     :Longint;                 {*Taux de Transfert (Byte/s)*}
  45.      BRate    :Longint;                 {*Best Taux de Transfert (Byte/s)*}
  46.      WRate    :Longint;                 {*Worse Taux de Transfert (Byte/s)*}
  47.  
  48.      Comments :String[64];              {*Commentaires Eventuels*}
  49.      End;
  50.  
  51. TYPE TParam   =Record           {====== STRUCTURE DES PARAMETRES ======}
  52.      Length   :Longint;                 {*Datas pour Ecriture sur DK*}
  53.      Buffer   :Longint;
  54.      TMoy     :Longint;                 {*Différents Temps*}
  55.      TBes     :Longint;
  56.      TWor     :Longint;
  57.      End;
  58.  
  59. Var  Modules  :String;                  {*Noms des Différents Modules*}
  60.      Qtt_Mod  :Byte;                    {*Nombres de Modules Existants*}
  61.      T        :Array[1..Max_Mod] Of TWrite;{*Tableau des Structures*}
  62.      P        :Array[1..Max_Pts] Of Integer;{*Tableau des Points Gfx*}
  63.      NbModules:Byte;                    {*Nombre de Modules*}
  64.      Handle   :Word;                    {*Handle du Fichier Pour ASM DOS*}
  65.      Macro    :Boolean;                 {*Pour Aff Graphique ou non*}
  66.      Qtt_Points:Longint;                {*Nombre de Points pour le Tableau*}
  67.      Max_Buffer:Integer;                {*Maximum Buffer pour Abscisse Repère*}
  68.      Freq     :Longint;                 {*Frequence du Timer en Hertz*}
  69.      PasFile  :File;                    {*Type Pour Fichier Pascal*}
  70.      Scan,Scan1:Longint;                {*Scan pour Macro*}
  71.      Step,Step1:Integer;                {*Pas Buffer pour Macro*}
  72.      Ite,Ite1 :Byte;                    {*Nb d'Iterations pour Macro*}
  73.      Help     :Boolean;                 {*Display Help on Gadgets*}
  74.      Drive    :Shortint;                {*Drive to be Writed with Tracks*}
  75.      XMin,XMax:Longint;                 {*Bornes Min et Max de la Courbe*}
  76.      Nb_Points:Integer;                 {*Nb de Points ds les Bornes*}
  77.      But_Lens :ButG;                    {*Bouton Lens*}
  78.  
  79.      Grid     :Boolean;                 {*Show Grid or No: True=Show*}
  80.      Del_File :Boolean;                 {*Delete File Test Automatiquely*}
  81.      Disp_Rate:Boolean;                 {*Affiche Rate Sinon Time*}
  82.      NoClear  :Boolean;                 {*Clear Screen or No*}
  83.  
  84.      DOS_Error:Word;                    {*Numéro de l'Erreur DOS*}
  85.      DOS_Class_Error,                   {*Le Pourquoi de l'Erreur*}
  86.      DOS_Correct_Error,                 {*Comment y Remedier*}
  87.      DOS_Local_Error:Byte;              {*Sa Localisation*}
  88.  
  89. { FWRITE.OBJ}                         {*Intégrer le module FWRITE en CPP*}
  90. { CS.LIB}
  91. { C0S.OBJ}
  92. { MATHS.LIB}
  93. { EMU.LIB}
  94.  
  95. {****************** PROCEDURES POUVANT ETRES APPELLEES **********************}
  96.  
  97. Procedure ERROR_09;                     {*Gestion des Erreurs*}
  98. Procedure ERROR_17;
  99. Procedure ERROR_18;
  100. Procedure ERROR_20;
  101. Procedure ERROR_21;
  102. Function  WARNING_14:Boolean;           {*Avertissement Write in Tracks*}
  103. Function  WARNING_19:Boolean;           {*Second Avertissement Write in Tracks*}
  104.  
  105. Procedure INIT_DATAS;                   {*Initialisation des Datas*}
  106. Procedure PARAMETERS_MODULES;           {*Definitions des Parametres*}
  107. Procedure CONFIGURE_MODULES;            {*Configurations des Modules*}
  108. Procedure MACRO_PREFS(Var Num:Byte; W4:Win; Var Choix:Byte);{*Paramètre et Execute Macro*}
  109. Procedure MAIN_RESULTS;                 {*Résultats Généraux*}
  110. Function  SELECT_DRIVE:Shortint;        {*Sélectionne Drive to Write Sectors*}
  111.  
  112. Procedure OPEN_PASCAL_FILE;             {*Procedures pour Pascal*}
  113. Procedure CLOSE_PASCAL_FILE;
  114. Procedure DELETE_PASCAL_FILE;
  115. Procedure WRITE_PASCAL_FILE(Var NBO:Word);
  116.  
  117. Procedure OPEN_DOS_FILE;                {*Procedures pour ASM - DOS*}
  118. Procedure CREATE_DOS_FILE;
  119. Procedure CLOSE_DOS_FILE;
  120. Procedure DELETE_DOS_FILE;
  121. Procedure WRITE_DOS_FILE(Var NBO:Word);
  122.  
  123. Procedure WRITE_TRACKS_I26(Var NBO:Word; NumDisk:Byte);{*Write Tracks With DOS*}
  124.  
  125. {Function  WRITE_FWCPP(NBO:Integer):Integer;  {*FWrite - CPP*}
  126.  
  127. Procedure DISPLAY_DOS_ERROR;             {*Affiche Erreurs DOS - INT $59*}
  128. Procedure DISPLAY_RESULTS_WRITING(Pos,It,NbO:Longint);{*Affiche Resultats Ecriture*}
  129. Function  CALC_TIME:Longint;             {*Renvois Difference en MicroSec*}
  130. Procedure INIT_TIME;                     {*Initialise le Temps*}
  131. Procedure COORDONEES_REPERE(W:Win; Var X1,Y1,X2,Y2:Integer);
  132. Procedure DRAW_REPERE(Num:Integer;W:Win);{*Affiche le Repère dans la Fenêtre*}
  133. Procedure DRAW_COURBE(Num:Integer;W:Win);{*Affiche la Courbe*}
  134. Procedure ZOOM_COURBE(Xa,Xb:Integer;Num:Byte;W:Win);{*Zoom sur les Points de la Courbe*}
  135. Procedure DRAW_GRID(W:Win);              {*Dessine la Grille*}
  136. Procedure UPDATE_GRID(Num:Integer;W:Win);{*Affiche ou Sucre la Grid*}
  137. Procedure UPDATE_ORDONEE(Num:Integer; Var W4:Win);{*Swap Beetween Time/Rate*}
  138. Procedure UPDATE_HELP;                   {*Switch for Help on Gadgets*}
  139. Procedure UPDATE_CLEAR;                  {*Switch for Clear Window*}
  140. Procedure UPDATE_FILE;
  141. Procedure AFF(Number:Byte);              {*Affiche Help*}
  142. Procedure ADD_GADGET_LENS(W:Win);        {*Add Gadget Lens*}
  143.  
  144. IMPLEMENTATION
  145.  
  146. {╔═══════════════════════════════════════════════════════════════════════════╗
  147.  ║                    FONCTIONS GET_PROCESSOR, GET_COPRO                     ║
  148.  ╠═══════════════════════════════════════════════════════════════════════════╣
  149.  ║ IN.....: /                                                                ║
  150.  ║ OUT....: Numéro Processor/CoPro.                                          ║
  151.  ║ EXPLAIN: Renvois un Numéro correspondant au type de Processeur et Copro.  ║
  152.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  153.  
  154. {Function WRITE_CPP_FWRITE(NBO:Integer):Integer; External;{*Recupère le .OBJ en Asm*}
  155.  
  156. {Function WRITE_FWCPP(NBO:Integer):Integer;          {*Transmet Resultat Proc*}
  157. {Begin WRITE_FWCPP:=WRITE_CPP_FWRITE(NBO); End;
  158.  
  159. {╔═══════════════════════════════════════════════════════════════════════════╗
  160.  ║                 - GESTION DES ERREURS PAR EZ-REQUEST -                    ║
  161.  ╠═══════════════════════════════════════════════════════════════════════════╣
  162.  ║ IN.....: /                                                                ║
  163.  ║ OUT....: /                                                                ║
  164.  ║ EXPLAIN: Affiche les Erreurs par un EZ-Request. (Plusieurs Procédures).   ║
  165.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  166.  
  167. {***************************** LIST IS EMPTY ********************************}
  168.  
  169. Procedure ERROR_01;
  170. Var NUM:Integer;
  171. Begin
  172. EZ_REQUESTG('D-SPEED REQUEST',          {*List is Empty*}
  173. 'MODULE LIST IS EMPTY|TRY CONFIGURE MODULES BEFORE USE US !|','_I KNOW !|',NUM);
  174. Modules:='|';                           {*Clear Module List*}
  175. End;
  176.  
  177. {************************* MODULE LIST NOT FOUND ****************************}
  178.  
  179. Procedure ERROR_02;
  180. Var NUM:Integer;
  181. Begin
  182. EZ_REQUESTG('D-SPEED REQUEST',
  183. 'FILE ''DSMODULE.LIS'' NOT FOUND|OPERATION ABORTED !|','_I KNOW !|',NUM);
  184. Modules:='|';                           {*Clear Module List*}
  185. End;
  186.  
  187. {********************** MODULES DATAS CAN'T BE SAVED ************************}
  188.  
  189. Procedure ERROR_03;
  190. Var NUM:Integer;
  191. Begin
  192. EZ_REQUESTG('D-SPEED REQUEST',
  193. 'CAN''T SAVE ''DSMODULE.DTA''|OPERATION ABORTED !|','_I KNOW !|',NUM);
  194. End;
  195.  
  196. {***************** FILE BUFFER MORE LARGE THAN FILE LENGTH ******************}
  197.  
  198. Procedure ERROR_04;
  199. Var NUM:Integer;
  200. Begin
  201. EZ_REQUESTG('D-SPEED REQUEST',
  202. 'FILE BUFFER CANNOT BE HIGHTER THAN FILE LENGTH|PREVIOUS VALUE WILL BE DISPLAYED|',
  203. '_I KNOW !|',NUM);
  204. End;
  205.  
  206. {************************* MODULES DATAS NOT FOUND **************************}
  207.  
  208. Procedure ERROR_05;
  209. Var NUM:Integer;
  210. Begin
  211. EZ_REQUESTG('D-SPEED REQUEST',
  212. 'FILE ''DSMODULE.DTA'' NOT FOUND|OPERATION ABORTED !|','_I KNOW !|',NUM);
  213. End;
  214.  
  215. {********************* CANNOT DELETE INTERNAL MODULES ***********************}
  216.  
  217. Procedure ERROR_06;
  218. Var NUM:Integer;
  219. Begin
  220. EZ_REQUESTG('D-SPEED REQUEST',
  221. 'CANNOT DELETE INTERNAL MODULES|OPERATION ABORTED !|','_I KNOW !|',NUM);
  222. End;
  223.  
  224. {*********************** MAXIMUM MODULES IS REACHED *************************}
  225.  
  226. Procedure ERROR_07;
  227. Var NUM:Integer;
  228. Begin
  229. EZ_REQUESTG('D-SPEED REQUEST',
  230. 'MAXIMUM MODULES IS REACHED !|OPERATION ABORTED !|','_I KNOW !|',NUM);
  231. End;
  232.  
  233. {************************ MODULE LIST CAN'T SAVED ***************************}
  234.  
  235. Procedure ERROR_08;
  236. Var NUM:Integer;
  237. Begin
  238. EZ_REQUESTG('D-SPEED REQUEST',
  239. 'MODULE LIS CANNOT UPDATED AND SAVED AS ''DSMODULE.LIS''|OPERATION ABORTED !|','_I KNOW !|',NUM);
  240. End;
  241.  
  242. {************************ ERROR WRITING TEST FILE ***************************}
  243.  
  244. Procedure ERROR_09;
  245. Var NUM:Integer;
  246. Begin
  247. EZ_REQUESTG('D-SPEED REQUEST',
  248. 'TEST FILE CANNOT BE CREATED|OPERATION ABORTED !|','_I KNOW !|',NUM);
  249. End;
  250.  
  251. {************************** FILE BUFFER TOO LARGE ***************************}
  252.  
  253. Procedure ERROR_10;
  254. Var NUM:Integer;
  255. Begin
  256. EZ_REQUESTG('D-SPEED REQUEST',
  257. 'FILE BUFFER CANNOT BE HIGHTER THAN 34464|PREVIOUS VALUE WILL BE DISPLAYED|','_I KNOW !|',NUM);
  258. End;
  259.  
  260. {********************* CAN'T HAVE ACCESS TO POINTS FILE *********************}
  261.  
  262. Procedure ERROR_11;
  263. Var NUM:Integer;
  264. Begin
  265. EZ_REQUESTG('D-SPEED REQUEST',
  266. 'I CAN''T HAVE ACCESS TO THE FILE|OPERATION ABORTED !|','_I KNOW !|',NUM);
  267. End;
  268.  
  269. {*********************** SIZE OR BUFFER EQUAL TO 0 !!! **********************}
  270.  
  271. Procedure ERROR_12;
  272. Var NUM:Integer;
  273. Begin
  274. EZ_REQUESTG('D-SPEED REQUEST',
  275. 'FILE SIZE OR BUFFER SIZE CANNOT BE EQUAL TO 0 |PREVIOUS VALUES WILL BE DISPLAYED|','_I KNOW !|',NUM);
  276. End;
  277.  
  278. {******************** FILE BUFFER CANNOT HIGHER THAN 65535 ******************}
  279.  
  280. Procedure ERROR_13;
  281. Var NUM:Integer;
  282. Begin
  283. EZ_REQUESTG('D-SPEED REQUEST',
  284. 'FILE BUFFER CANNOT BE HIGHTER THAN 65535|PREVIOUS VALUE WILL BE DISPLAYED|','_I KNOW !|',NUM);
  285. End;
  286.  
  287. {********************* BE CARREFULL - WRITTING TRACKS !!! *******************}
  288.  
  289. Function WARNING_14:Boolean;                 {*Avertissement Write in Tracks*}
  290. Var NUM:Integer;
  291. Begin
  292. EZ_REQUESTG('D-SPEED REQUEST',
  293. '*** WARNING ***||THIS MODULE WRITE TRACKS ON YOUR DISK|'+
  294. 'AND ALL YOUR FILES AND DIRECTORIES WILL BE SCRATCHED,|'+
  295. 'YOU MUST USE A TOTAL FREE PARTITION.||'+
  296. 'SHALL I CONTINUE ?|','<<< _YES >>>| _NO |',NUM);
  297. If NUM<>1 Then WARNING_14:=False Else WARNING_14:=True;
  298. End;
  299.  
  300. {*********************** MAXIMUM QTT POINTS IS REACHED **********************}
  301.  
  302. Procedure ERROR_15;
  303. Var NUM:Integer;
  304.     St :String;
  305. Begin
  306. Str(Max_Pts,St);
  307. EZ_REQUESTG('D-SPEED REQUEST',
  308. 'NUMBER OF POINTS TO STOCK IS TOO MUCH,|MAXIMUM = '+St+'|'+
  309. 'PLEASE CHOOSE ANOTHER VALUE FOR SCAN OR STEP|','_I KNOW !|',NUM);
  310. End;
  311.  
  312. {***************** STEP CANNOT BE HIGHTER THAN SCAN BUFFER ******************}
  313.  
  314. Procedure ERROR_16;
  315. Var NUM:Integer;
  316. Begin
  317. EZ_REQUESTG('D-SPEED REQUEST',
  318. 'STEP SIZE CANNOT BE HIGHTER THAN SCAN SIZE|'+
  319. 'PLEASE CHOOSE ANOTHER VALUE FOR STEP|','_I KNOW !|',NUM);
  320. End;
  321.  
  322. {********************* UNABLE TO SAVE CONFIGURATION FILE ********************}
  323.  
  324. Procedure ERROR_17;
  325. Var NUM:Integer;
  326. Begin
  327. EZ_REQUESTG('D-SPEED REQUEST',
  328. '! DISK ERROR !|'+
  329. 'UNABLE TO SAVE CONFIGURATION FILE|','_I KNOW !|',NUM);
  330. End;
  331.  
  332. {********************* UNABLE TO READ CONFIGURATION FILE ********************}
  333.  
  334. Procedure ERROR_18;
  335. Var NUM:Integer;
  336. Begin
  337. EZ_REQUESTG('D-SPEED REQUEST',
  338. '! DISK ERROR !|'+
  339. 'UNABLE TO READ CONFIGURATION FILE|','_I KNOW !|',NUM);
  340. End;
  341.  
  342. {******************* BE CARREFULL - WRITTING TRACKS II !!! ******************}
  343.  
  344. Function WARNING_19:Boolean;                 {*Avertissement Write in Tracks*}
  345. Var NUM:Integer;
  346. Begin
  347. EZ_REQUESTG('D-SPEED REQUEST',
  348. '! IT''S NOT A JOKE !|'+
  349. 'IF YOU SELECT (YES) YOUR DISK PARTITION WILL BE TOTATLY SCRACHED|'+
  350. 'IT''S THE LAST ADVERTISMENT BEFORE EXECUTION.||'+
  351. 'SHALL I REALLY CONTINUE ?|',' _YES | _NO |',NUM);
  352. If NUM<>1 Then WARNING_19:=False Else WARNING_19:=True;
  353. End;
  354.  
  355. {************************ FONCTION NOT IMPLEMENTED **************************}
  356.  
  357. Procedure ERROR_20;
  358. Var NUM:Integer;
  359. Begin
  360. EZ_REQUESTG('D-SPEED REQUEST',
  361. 'FUNCTION NOT IMPLEMENTED|'+
  362. 'WAIT FOR THE NEXT VERSION TO USE IT|','_I KNOW !|',NUM);
  363. End;
  364.  
  365. {************************* MODULE NOT IMPLEMENTED ***************************}
  366.  
  367. Procedure ERROR_21;
  368. Var NUM:Integer;
  369. Begin
  370. EZ_REQUESTG('D-SPEED REQUEST',
  371. 'MODULE NOT IMPLEMENTED|'+
  372. 'PLEASE SELECT ANOTHER MODULE|','_I KNOW !|',NUM);
  373. End;
  374.  
  375. {************************* DATA FILE UNKNOWN FORMAT *************************}
  376.  
  377. Procedure ERROR_22;
  378. Var NUM:Integer;
  379. Begin
  380. EZ_REQUESTG('D-SPEED REQUEST',
  381. 'DATA FILE UNKNOWN FORMAT|'+
  382. 'IT''S NOT A (DS) DATA FILE, PLEASE SELECT ANOTHER FILE|','_I KNOW !|',NUM);
  383. End;
  384.  
  385. {╔═══════════════════════════════════════════════════════════════════════════╗
  386.  ║                       PROCEDURE DISPLAY_DOS_ERRORS                        ║
  387.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  388.  
  389. Procedure DISPLAY_DOS_ERROR;
  390. Var St1,St2,St3,St4:String;
  391.     NUM:Integer;
  392. Begin
  393. Set_Pointer(P_Arrow);
  394. Str(DOS_Error,St1); Str(DOS_Class_Error,St2);
  395. Str(DOS_Correct_Error,St3); Str(DOS_Local_Error,St4);
  396. EZ_REQUESTG('D-SPEED REQUEST','--- AN ERROR HAS OCCURED ---||'+
  397.             'DOS ERROR: '+St1+
  398.             '|DOS ERROR CLASS: '+St2+
  399.             '|DOS ERROR CORRECTION: '+St3+
  400.             '|DOS ERROR LOCALISATION: '+St4+'|'
  401.             ,'_I KNOW |',NUM);
  402. DOS_Error:=0;                           {*Set Error to 0 after Read it*}
  403. End;
  404.  
  405. {╔═══════════════════════════════════════════════════════════════════════════╗
  406.  ║                    - AFFICHE L'AIDE SUR LES GADGETS -                     ║
  407.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  408.  
  409. Procedure AFF(Number:Byte);             {*Affiche Help*}
  410. Begin
  411. If Help=False Then Exit;                {*Pas de Help => On Sort*}
  412. SetColor(Col15);
  413. BEVEL(3,GetMaxY-20,636,GetMaxY-3,1,4,False,True);
  414. Case Number of
  415.   1: DispG(20,332,Col4,'SET PARAMETERS AND EXECUTE A MACRO');
  416.   2: DispG(20,332,Col4,'EXECUTE CURRENT MACRO WITH DEFINED PARAMETERS');
  417.   3: DispG(20,332,Col4,'OPERATION CANCELED');
  418.   4: DispG(20,332,Col4,'LOAD DATAS POINTS AND DISPLAY IT IN THE GFX WINDOW');
  419.   5: DispG(20,332,Col4,'SAVE CALCULATED POINTS AS A DATA FILE');
  420.   6: DispG(20,332,Col4,'SELECT A TYPE OF REPRESENTATION');
  421.   7: DispG(20,332,Col4,'SELECT THE VARIABLE TO BE ANALYSED');
  422.   8: DispG(20,332,Col4,'DISPLAY RESULTS IN A BI-DIMENSIONAL ARRAY (DATA BASE)');
  423.   9: DispG(20,332,Col4,'DISPLAY RESULTS WITH GRAPHICAL REPRESENTATION');
  424.  10: DispG(20,332,Col4,'SHOW RESULTS OF WRITING TESTS');
  425.  11: DispG(20,332,Col4,'SHOW AND MODIFIE MODULES PARAMETERS');
  426.  12: DispG(20,332,Col4,'SELECT PATH AND NAME FOR AN EXTERNAL MODULE');
  427.  13: DispG(20,332,Col4,'EDIT COMMENTS FOR THE CURRENT MODULE (OPTIONAL)');
  428.  14: DispG(20,332,Col4,'SELECT THE MODULE TO VIEW PARAMETERS');
  429.  15: DispG(20,332,Col4,'DISPLAY MEMORY STATUS (CONVENTIONAL MEMORY, EMS, XMS), AND THE DOS VERSION');
  430.  16: DispG(20,332,Col4,'EXIT D-SPEED ??? - DON''T FORGET TO SAVE YOUR DATAS');
  431.  17: DispG(20,332,Col4,'DISPLAY THE ''ABOUT'' TEXT FOR D-SPEED v1.0');
  432.  18: DispG(20,332,Col4,'DISPLAY SOME INFO ON D-SPEED v1.0');
  433.  19: DispG(20,332,Col4,'GO TO WRITE TEST FILE WITH THE CURRENT MODULE (SEE BELOW)');
  434.  20: DispG(20,332,Col4,'TEST FILE WILL NOT BE DELETED. NOW, DEFRAG THE TEST FILE AND TRY AGAIN TEST.');
  435.  21: DispG(20,332,Col4,'SELECT THE TYPE OF REPRESENTATION (WRITING TIME OR RATE TRANSFERT)');
  436.  22: DispG(20,332,Col4,'DISPLAY OR NO INLINE HELP');
  437.  23: DispG(20,332,Col4,'DISPLAY GRID OR NO');
  438.  24: DispG(20,332,Col4,'SELECT THE CURRENT MODULE TO BE USED');
  439.  25: DispG(20,332,Col4,'SELECT YOUR COLORS IN PALETTE');
  440.  26: DispG(20,332,Col4,'SELECT YOUR FAVORITE FONT');
  441.  27: DispG(20,332,Col4,'SHOW YOUR HARDWARE CONFIGURATION');
  442.  28: DispG(20,332,Col4,'LOAD THE D-SPEED CONFIGURATION FILE');
  443.  29: DispG(20,332,Col4,'SAVE THE D-SPEED CONFIGURATION FILE');
  444.  30: DispG(20,332,Col4,'ADD OR SUB A NEW EXTERNAL MODULE AND SET PATH AND NAME FOR IT');
  445.  31: DispG(20,332,Col4,'SHOW AND MODIFIE THE M.O.S SYSTEM CONFIGURATION');
  446.  32: DispG(20,332,Col4,'SAVE THE NEW MODULES CONFIGURATION');
  447.  33: DispG(20,332,Col4,'ADD AND APPEND A NEW MODULE IN MODULE LIST');
  448.  34: DispG(20,332,Col4,'DELETE THE LAST MODULE IN THE LIST');
  449.  35: DispG(20,332,Col4,'SELECT MODULE TO MODIFIE DATAS');
  450.  36: DispG(20,332,Col4,'UNDO MODIFS AND GO BACK TO MAIN SCREEN');
  451.  37: DispG(20,332,Col4,'MODIFIE STRUCTURE OF THE GFX WINDOW');
  452.  38: DispG(20,332,Col4,'SCROLL THE LIST OF MODULES TO SHOW RESULTS');
  453.  39: DispG(20,332,Col4,'PLEASE SELECT DRIVE TO BE WRITED WITH SECTORS');
  454.  40: DispG(20,332,Col4,'ENABLE/DISABLE MULTI GRAPHICS ON GFX WINDOW');
  455.  41: DispG(20,332,Col4,'SELECT GFX BLOCK TO ZOOM');
  456.  42: DispG(20,332,Col4,'UNCLICK R.M.B HAS MADE ZOOM. USE THE ''LENS ICON'' ON TITLE WINDOW TO UNZOOM');
  457.  43: DispG(20,332,Col4,'DRAG POINTER IN WINDOW TO SHOW COORDINATES');
  458.  44: DispG(20,332,Col4,'READY...');
  459.  45: DispG(20,332,Col4,'TEST FILE WILL BE DELETED. NO DEFRAG TEST WILL BE PERFORMING');
  460.   End;
  461. SetColor(Col0);
  462. End;
  463.  
  464. {╔═══════════════════════════════════════════════════════════════════════════╗
  465.  ║                   - CALCULE LES COORDONEES DU REPERE -                    ║
  466.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  467.  
  468. Procedure COORDONEES_REPERE(W:Win; Var X1,Y1,X2,Y2:Integer);
  469. Begin
  470. X1:=W.X1+LaF*4+14; Y1:=W.Y2-HaF-12;     {*Calcule Coordonées du Repère*}
  471. X2:=W.X2-HaF-10; Y2:=W.Y1+HaF+20;
  472. End;
  473.  
  474. {╔═══════════════════════════════════════════════════════════════════════════╗
  475.  ║                            - ADD_GADGET_LENS -                            ║
  476.  ╠═══════════════════════════════════════════════════════════════════════════╣
  477.  ║ IN.....: /                                                                ║
  478.  ║ OUT....: /                                                                ║
  479.  ║ EXPLAIN: Ajoute et Affiche le Gadget Lens dals la Fenêtre des Gfx.        ║
  480.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  481.  
  482. Procedure ADD_GADGET_LENS(W:Win);
  483. Begin
  484. If (XMin<>1) Or (XMax<>Qtt_Points) Then
  485.    Begin
  486.    W.NbGsp:=3;
  487.    ButtonG(W.X2-20*W.NbGsp,W.Y1,20,False,But_Lens,'');
  488.    But_Lens.ButSp:=10;
  489.    PutImage(W.X2-20*W.NbGsp+1,W.Y1+1,GpD^,NormalPut);
  490.    SetColor(Col0); Line(W.X2-20*W.NbGsp-1,W.Y1,W.X2-20*W.NbGsp-1,W.Y1+HaF+4);
  491.    End;
  492. End;
  493.  
  494. {╔═══════════════════════════════════════════════════════════════════════════╗
  495.  ║                 - AFFICHE LE REPERE DAND LA FENETRE GFX -                 ║
  496.  ╠═══════════════════════════════════════════════════════════════════════════╣
  497.  ║ IN.....: /                                                                ║
  498.  ║ OUT....: /                                                                ║
  499.  ║ EXPLAIN: Affiche le Repère de Base dans la Fenêtre des Gfx.               ║
  500.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  501.  
  502. Procedure DRAW_REPERE(Num:Integer; W:Win);{*Affiche le Repère dans la Fenêtre*}
  503. Var X1,Y1,X2,Y2:Integer;                {*Coordonées du Repère*}
  504.     Px  :Longint;                       {*Internal Var*}
  505.     PxR :Real;                          {*Internal Var*}
  506.     A   :Longint;
  507.     St  :String;
  508.     High_Point:Longint;                 {*Valeur du Point le Plus Elevé*}
  509.  
  510. Begin
  511. COORDONEES_REPERE(W,X1,Y1,X2,Y2);       {*Calcule Coordonée du Repère*}
  512. SetColor(0);
  513.  
  514. High_Point:=0;                          {*On Recherche la Valeur Maximum*}
  515. For A:=XMin to XMax do                  {*du Tableau*}
  516.    If P[A]>High_Point Then High_Point:=P[A];
  517. If (High_Point=0) Or (Qtt_Points=0) Then
  518.    Begin Qtt_Points:=100; High_Point:=400; End;
  519.  
  520. If Disp_Rate=False Then
  521.    Begin
  522.    High_Point:=0;                       {*On Recherche la Valeur Maximum*}
  523.    For A:=XMin to XMax do               {*Du Tableau*}
  524.        If P[A]>High_Point Then High_Point:=P[A];
  525.    If (High_Point=0) Or (Qtt_Points=0) Then
  526.       Begin Qtt_Points:=100;            {*Valeurs par Défaut*}
  527.       High_Point:=700; End;
  528.    End;
  529.  
  530. HideMouse;
  531. Line(X1,Y1,X1,Y2);                      {*Draw Line Horizontale du Repère*}
  532. Line(X1,Y1,X2,Y1);                      {*Draw Line Verticale du Repère*}
  533. PutImage(X2-1,Y1-6,Gp3^,NormalPut);     {*draw Arrows Aux Extrémitées*}
  534. PutImage(X1-8,Y2-11,Gp4^,NormalPut);
  535.  
  536. A:=0;                                   {*Init Data*}
  537.  
  538. Repeat
  539. If A Mod 10=0 Then Begin                {*Draw Repère Horizontal*}
  540.                  Line(X1+A*3,Y1-4,X1+A*3,Y1+4);
  541.                  Px:=Round((Max_Buffer*A*3)/Abs(X2-X1));
  542.                  If Px>=1024 Then Begin {*Exprime en Kb au Lieu de Byte*}
  543.                     PxR:=Px/1024;
  544.                     Str(PxR:3:1,St);
  545.                     End
  546.                  Else Str(Px,St);       {*Calul Pos X*}
  547.                  OutTextXY(X1+A*3-LaF-2,Y1+7,St);
  548.                  End
  549.               Else Line(X1+A*3,Y1-2,X1+A*3,Y1+2);
  550. Inc(A);
  551. Until X1+A*3>X2;
  552.  
  553. A:=0;
  554. Repeat
  555. If A Mod 10=0 Then Begin                {*Draw Repère Vertical*}
  556.                  Line(X1-4,Y1-A*2,X1+4,Y1-A*2);
  557.                  Str(Round((High_Point*A*2)/Abs(Y2-Y1)),St);{*Calul Pos Y*}
  558.                  OutTextXY(X1-24-LaF,Y1-A*2-6,St);
  559.                  End
  560.               Else Line(X1-2,Y1-A*2,X1+2,Y1-A*2);
  561. Inc(A);
  562. Until Y1-A*2<Y2;
  563. ShowMouse;
  564. End;
  565.  
  566. {╔═══════════════════════════════════════════════════════════════════════════╗
  567.  ║                          PROCEDURE ZOOM_COURBE                            ║
  568.  ╠═══════════════════════════════════════════════════════════════════════════╣
  569.  ║ EXPLAIN: Zoom sur les Points de la Courbe dans la Fenêtre Gfx.            ║
  570.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  571.  
  572. Procedure ZOOM_COURBE(Xa,Xb:Integer; Num:Byte; W:Win);
  573. Var X1,Y1,X2,Y2:Integer;                     {*Coordonées du Repère*}
  574.     Trans:Real;
  575.     OldXMin:Integer;
  576.  
  577. Begin
  578. COORDONEES_REPERE(W,X1,Y1,X2,Y2);            {*Calcule Coordonée du Repère*}
  579. If Xa>Xb Then Exg(Xa,Xb);                    {*Sens du Box => Permutation*}
  580.  
  581. OldXMin:=XMin;
  582. Trans:=(Nb_Points/(X2-X1))*Xb; XMax:=XMin+Round(Trans); {*Calcule Borne Max*}
  583. Trans:=(Nb_Points/(X2-X1))*Xa; XMin:=XMin+Round(Trans)-1; {*Calcule Borne Min*}
  584.  
  585. If XMin<1 Then XMin:=1;
  586. If XMax>Nb_Points+XMin-1 Then XMax:=Nb_Points+XMin-1;
  587. If XMax<XMin Then XMax:=XMin;
  588. If XMax-XMin<2 Then Begin XMin:=OldXMin; XMax:=XMin+1; End;
  589.  
  590. If (XMin=XMax) Or (XMax<1) Then Exit;        {*Erreur de Coordonées*}
  591. Nb_Points:=XMax-XMin+1;                      {*Calcul du Nombre de Points*}
  592.  
  593. {gotoxy(1,5); writeln('Xa=',Xa,' Xb=',Xb,'     ');
  594. gotoxy(1,6); writeln('XMin=',XMin,' XMax=',XMax,'     ');
  595. gotoxy(1,7); writeln('Nb_Points=',Nb_Points,'  ');}
  596.  
  597. If NoClear=False Then CLEAR_WINDOW(W);     {*Cls Window*}
  598. DRAW_REPERE(Num,W);                 {*Affiche le Repère*}
  599. If Grid=True Then DRAW_GRID(W);     {*Affiche la Grille*}
  600. DRAW_COURBE(Num,W);                 {*Affiche la Courbe*}
  601. ADD_GADGET_LENS(W);
  602. End;
  603.  
  604. {╔═══════════════════════════════════════════════════════════════════════════╗
  605.  ║                          PROCEDURE DRAW_COURBE                            ║
  606.  ╠═══════════════════════════════════════════════════════════════════════════╣
  607.  ║ EXPLAIN: Affiche à Nouveau la Courbe dans la Fenêtre Gfx.                 ║
  608.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  609.  
  610. Procedure DRAW_COURBE(Num:Integer; W:Win);
  611. Var Pos:Integer;                        {*Position dans Tableau*}
  612.     X1,Y1,X2,Y2:Integer;                {*Coordonées du Repère*}
  613.     OldX,OldY:Longint;                  {*Anciennes Coordonées*}
  614.     Px,Py:Longint;                      {*Position X et Y du point*}
  615.     StockX:Real;                        {*Stockage Trés Long Pour Eviter Bug*}
  616.     PasX:Real;                          {*Pas en X*}
  617.     High_Point:Integer;                 {*Valeur du Point le Plus Elevé*}
  618.     IncX:Real;                          {*Augmentation du Pas X*}
  619.  
  620. Begin
  621. High_Point:=0;                          {*On Recherche la Valeur Maximum*}
  622. For Pos:=XMin to XMax do                {*du Tableau*}
  623.    If P[Pos]>High_Point Then High_Point:=P[Pos];
  624. Pos:=XMin;                              {*Xeme Elément du Tableau = First*}
  625. If (High_Point=0) Or (Qtt_Points=0) Then Exit;
  626. COORDONEES_REPERE(W,X1,Y1,X2,Y2);       {*Calcule les Coordonées*}
  627. X1:=X1-W.X1-1; Y1:=Y1-W.Y1-16;          {*Deplace Coordonées pour Clipping*}
  628. X2:=X2-W.X1; Y2:=Y2-W.Y1;
  629. OldX:=X1;                               {*Save Olds Coordonées*}
  630. If Disp_Rate=True Then OldY:=Y1         {*Point de Depart = Fn(Time ou Rate)*}
  631.                   Else OldY:=-200;
  632. PasX:=Abs(X2-X1)/(Nb_Points-1);         {*Calcul du Pas X*}
  633. IncX:=PasX;                             {*Initialisation des Incréments*}
  634.    Repeat
  635.    Px:=Round(X1+IncX);                  {*Calcul Position X et Y*}
  636.    StockX:=Abs(Y1-Y2+20)/High_Point;
  637.    Py:=Y1-Round(StockX*P[Pos]);
  638.  
  639.    SetColor(Col13);                     {*Determine Couleur de Tracé*}
  640.    If (P[Pos]=0) Or (OldY=Y1) Then If Pos<>1 Then SetColor(Col9) Else
  641.                Else SetColor(Col13);
  642.  
  643.    Clip_Window(ClipOn,W);               {*Clipping Window On*}
  644.    Hidemouse;
  645.    Line(OldX,OldY,Px,Py);               {*Draw Line*}
  646.    ShowMouse;
  647.    Clip_Window(ClipOff,W);              {*Clipping Window Off*}
  648.    OldX:=Px; OldY:=Py;
  649.    Inc(Pos);                            {*Next Element*}
  650.    IncX:=IncX+PasX;                     {*Addition du Pas à L'Incrément*}
  651.    Until Pos>=XMax;                     {*Parcours tout le Tableau -> XMax*}
  652. End;
  653.  
  654. {╔═══════════════════════════════════════════════════════════════════════════╗
  655.  ║                   - CALCULE LE TEMP EN MILLISECONDES -                    ║
  656.  ╠═══════════════════════════════════════════════════════════════════════════╣
  657.  ║ IN.....: /                                                                ║
  658.  ║ OUT....: /                                                                ║
  659.  ║ EXPLAIN: Calcul du temps en DixMillisecondes entre deux Periodes Données. ║
  660.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  661.  
  662. Procedure INIT_TIME;
  663. Begin
  664. Set_Timer(Freq);                        {*Initialise Timer to Freq Hertz*}
  665. End;
  666.  
  667. Function CALC_TIME:Longint;             {*Renvois Difference en MicroSec*}
  668. Begin
  669. CALC_TIME:=CountT;                      {*Transmet le Temps*}
  670. Restore_Timer;                          {*Restore Normal Timer*}
  671. End;
  672.  
  673. {╔═══════════════════════════════════════════════════════════════════════════╗
  674.  ║                - CHARGEMENT DU FICHIER "DSMODULE.DTA" -                   ║
  675.  ╠═══════════════════════════════════════════════════════════════════════════╣
  676.  ║ IN.....: /                                                                ║
  677.  ║ OUT....: True/False (BOOLEAN): Chargement Correctement Effectué ou pas.   ║
  678.  ║ EXPLAIN: Charge les Différents Modules Datas contenus dans "DSMODULE.DTA".║
  679.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  680.  
  681. Function LOAD_MODULES_DATAS:Boolean;    {*Charges Les Datas des Modules*}
  682. Var   St  :String;
  683.       Fil1:Text;
  684.       P   :Byte;                        {*Nb De Modules Lus*}
  685.  
  686. {╔═══════════════════════════════════════════════════════════════════════════╗
  687.  ║                  - ASSIGNEMENT DES DATAS DES MODULES -                    ║
  688.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  689.  
  690. Procedure ASSIGN_DATAS;
  691. Var X:String;                           {*Trash Variable*}
  692. Begin
  693. Readln(Fil1,X); Readln(Fil1,X);
  694. Readln(Fil1,T[P].Name);                 {*Init Labels*}
  695. Readln(Fil1,T[P].FName);
  696. Readln(Fil1,T[P].FPath);
  697. Readln(Fil1,T[P].Fragment);
  698. Readln(Fil1,T[P].Length);               {*Tableau des Paramêtres*}
  699. Readln(Fil1,T[P].Buffer);
  700. Readln(Fil1,T[P].System);
  701. Readln(Fil1,T[P].Algo);
  702. Readln(Fil1,T[P].StatusMod);
  703. Readln(Fil1,T[P].Number);
  704. Readln(Fil1,T[P].Time);
  705. Readln(Fil1,T[P].Rate);
  706. Readln(Fil1,T[P].BRate);
  707. Readln(Fil1,T[P].WRate);
  708. Readln(Fil1,T[P].Comments);             {*Read Comments*}
  709. Readln(Fil1,X);                         {*Skip Blank Line*}
  710. End;
  711.  
  712. Begin
  713. Assign(Fil1,'DSMODULE.DTA');
  714. {$I-}
  715. Reset(Fil1);
  716. {$I+}
  717. If IOResult=0 Then                      {*Teste les Erreurs...*}
  718.    Begin
  719.    P:=1;                                {*1er Module*}
  720.    While Not Eof(Fil1) do
  721.       Begin
  722.       ASSIGN_DATAS;                     {*Lecture 1er Module*}
  723.       Inc(P);
  724.       End;
  725.    LOAD_MODULES_DATAS:=True;            {*Loading Succesfull*}
  726.    Close(Fil1);
  727.    NbModules:=P-1;                      {*Nb de Modules*}
  728.    End
  729.    Else LOAD_MODULES_DATAS:=False;      {*Error Loading !*}
  730. End;
  731.  
  732. {╔═══════════════════════════════════════════════════════════════════════════╗
  733.  ║                     - SWITCH DE L'HELP SUR GADGETS -                      ║
  734.  ╠═══════════════════════════════════════════════════════════════════════════╣
  735.  ║ EXPLAIN: Commute l'aide sur les Gadgets.                                  ║
  736.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  737.  
  738. Procedure UPDATE_HELP;
  739. Begin
  740. BEVEL(3,GetMaxY-20,636,GetMaxY-3,1,4,False,True);
  741. AFF(22);                                {*Help on Gadgets*}
  742. If Help=True Then Help:=False Else Help:=True;
  743. End;
  744.  
  745. {╔═══════════════════════════════════════════════════════════════════════════╗
  746.  ║                         - SWITCH DU DELETE FILE -                         ║
  747.  ╠═══════════════════════════════════════════════════════════════════════════╣
  748.  ║ EXPLAIN: Commute le Delete File pour Defragmenter.                        ║
  749.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  750.  
  751. Procedure UPDATE_FILE;
  752. Begin AFF(20);
  753. If Del_File=True Then Begin
  754.    AFF(20); Del_File:=False;
  755.    CREATE_DOS_FILE;                     {*Crée Fichier pour Write*}
  756.    CLOSE_DOS_FILE;                      {*Le Referme*}
  757.    End
  758.    Else Begin
  759.    AFF(45); Del_File:=True;
  760.    DELETE_DOS_FILE;                     {*Suprime Fichier car Delete*}
  761.    End;
  762. End;
  763.  
  764. {╔═══════════════════════════════════════════════════════════════════════════╗
  765.  ║                      - SWITCH DU CLEAR SUR GADGETS -                      ║
  766.  ╠═══════════════════════════════════════════════════════════════════════════╣
  767.  ║ EXPLAIN: Commute le Cls de la Fenêtre Graphique.                          ║
  768.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  769.  
  770. Procedure UPDATE_CLEAR;
  771. Begin
  772. AFF(40);                                {*Help on Gadgets*}
  773. If NoClear=True Then NoClear:=False Else NoClear:=True;
  774. End;
  775.  
  776. {╔═══════════════════════════════════════════════════════════════════════════╗
  777.  ║                      - INITIALISATION DES DATAS -                         ║
  778.  ╠═══════════════════════════════════════════════════════════════════════════╣
  779.  ║ IN.....: /                                                                ║
  780.  ║ OUT....: /                                                                ║
  781.  ║ EXPLAIN: Initialise la Liste des Modules et Quelques Babioles.            ║
  782.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  783.  
  784. Procedure INIT_DATAS;
  785. Var  Fil1    :Text;                     {*Fichier Texte des Datas Modules*}
  786.      Code    :Integer;                  {*Pour Conversion Val*}
  787.      NUM     :Integer;
  788.      St      :String;
  789.      A       :Integer;
  790.  
  791. Begin
  792. SetRGBPalette(Col9,58,12,00);           {*Couleurs Modifiées*}
  793. SetRGBPalette(Col11,46,43,40);
  794. Qtt_Points:=100;                        {*Arbitraire*}
  795. Max_Buffer:=10000;                      {*Taille Buffer pour Abscisse Repère*}
  796. Grid:=True;                             {*Show Grid*}
  797. Del_File:=True;                         {*Supression du Fichier Test en Auto*}
  798. Disp_Rate:=True;                        {*Display Rate de Base*}
  799. Freq:=1000;                             {*Timer de 1000 Hertz*}
  800. Scan:=10; Scan1:=Scan;                  {*Scan pour Macro*}
  801. Step:=1; Step1:=Step;                   {*Pas du Buffer pour Macro*}
  802. Ite:=1; Ite1:=Ite;                      {*Nb d'itérations pour Macro*}
  803. Help:=True;                             {*Help sur Gadgets de Base*}
  804. NoClear:=False;                         {*On Clear la Gfx Window à Chaque Fois*}
  805. XMin:=1; XMax:=100;                     {*Bornes Min et Max de la Courbe*}
  806. Nb_Points:=XMax-XMin+1;                 {*Calcul Nb de Points*}
  807.  
  808. Assign(Fil1,'DSMODULE.LIS');            {*Try to Load "DSMODULE.LIS"*}
  809. {$I-}
  810. Reset(Fil1);                            {*Open It*}
  811. {$I+}
  812. Modules:='';                            {*Clear Module Old List*}
  813. Qtt_Mod:=0;                             {*Nombres de Modules Existants*}
  814. If IOResult=0 Then                      {*Teste les Erreurs...*}
  815.    Begin
  816.    Readln(Fil1,Modules);                {*Read Module Name*}
  817.    For A:=1 to Length(Modules) do
  818.       If Copy(Modules,A,1)='|' Then
  819.          Qtt_Mod:=Qtt_Mod+1;            {*1 Module de Plus*}
  820.    End
  821.    Else Begin
  822.    ERROR_02; Exit;                      {*List Not Found...*}
  823.    End;
  824.  
  825. If LOAD_MODULES_DATAS=False Then        {*Charges Les Datas des Modules*}
  826.    Begin
  827.    ERROR_05;                            {*Module Datas not Found*}
  828.    End;
  829. End;
  830.  
  831. {╔═══════════════════════════════════════════════════════════════════════════╗
  832.  ║                        - SAVE AND RESTORE POINTS -                        ║
  833.  ╠═══════════════════════════════════════════════════════════════════════════╣
  834.  ║ IN.....: /                                                                ║
  835.  ║ OUT....: /                                                                ║
  836.  ║ EXPLAIN: Procedures de Sauvegarde et d'Ecriture des Coordonées de Points. ║
  837.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  838.  
  839. Procedure SAVE_POINTS(Num:Integer; PF:String);     {*Save Points*}
  840. Var Fil1:Text;
  841.     A:Integer;
  842.     St:String;
  843. Begin
  844. Assign(Fil1,PF);
  845. {$I-}
  846. Rewrite(Fil1);
  847. {$I+}
  848. If IOResult=0 Then Begin
  849.    Str(T[Num].Length,St); St:='FILESIZE='+St; Writeln(Fil1,St);{*Save FileSize*}
  850.    Str(Max_Buffer,St); St:='SCAN='+St; Writeln(Fil1,St);{*Save Maximum Abscisse pour Repère*}
  851.    Str(Step,St); St:='STEP='+St; Writeln(Fil1,St);      {*Step*}
  852.    Str(Ite,St); St:='PASS='+St; Writeln(Fil1,St);       {*Itérations*}
  853.    Str(Num,St); St:='MODULE='+St; Writeln(Fil1,St);     {*Numéro du Module*}
  854.    Str(Qtt_Points,St); St:='QTT POINTS='+St; Writeln(Fil1,St);{*Nb de Points*}
  855.    Writeln(Fil1,'');                    {*Ligne Vide*}
  856.    For A:=1 to Qtt_Points-1 do
  857.        Writeln(Fil1,P[A]);
  858.    Close(fil1);
  859.    End Else ERROR_11;                   {*Can't Save*}
  860. End;
  861.  
  862. Procedure LOAD_POINTS(Var Num:Byte; PF:String);{*Load Points*}
  863. Var Fil1:Text;
  864.     A,Code:Integer;
  865.     St,St0,St1,St2,St3,St4,St5:String;
  866.     Result:Integer;
  867.  
  868. Begin
  869. Assign(Fil1,PF);
  870. {$I-}
  871. Reset(Fil1);
  872. {$I+}
  873. If IOResult=0 Then Begin
  874.    Readln(Fil1,St0);                     {*Read FileSize*}
  875.    If Copy(St0,1,9)<>'FILESIZE=' Then Begin   {*Ce n'est pas 1 bon Fichier !*}
  876.       Max_Buffer:=0;                     {*Pour Indiquer une Erreur*}
  877.       ERROR_22;
  878.       Exit;
  879.       End;
  880.    St0:=Copy(St0,10,Length(St0)-9);
  881.  
  882.    Readln(Fil1,St1);                     {*Restore Maximum Abscisse pour Repère*}
  883.    St1:=Copy(St1,6,Length(St1)-5); Val(St1,Max_Buffer,Code);
  884.  
  885.    Readln(Fil1,St2);                     {*Step*}
  886.    St2:=Copy(St2,6,Length(St2)-5); Val(St2,Step,Code);
  887.  
  888.    Readln(Fil1,St3);                     {*Itérations*}
  889.    St3:=Copy(St3,6,Length(St3)-5); Val(St3,Ite,Code);
  890.  
  891.    Readln(Fil1,St4);                     {*Restore Numéro Module Utilisé*}
  892.    St4:=Copy(St4,8,Length(St4)-7); Val(St4,Num,Code);
  893.  
  894.    Readln(Fil1,St5);                     {*Nb de Points*}
  895.    St5:=Copy(St5,12,Length(St5)-11);
  896.  
  897.    Readln(Fil1,St);                      {*Skip Ligne Vide*}
  898.    A:=1;
  899.    While Not Eof(Fil1) do
  900.        Begin
  901.        Readln(Fil1,P[A]);
  902.        Inc(a);
  903.        End;
  904.    Close(Fil1);
  905.    Qtt_Points:=A;
  906.    EZ_REQUESTG('D-SPEED REQUEST','DATAS CORRECTLY READED,||'+
  907.                'FILE SIZE = '+St0+
  908.                '|BUFFER SCAN RANGE = 0 <-> '+St1+
  909.                '|STEP BUFFER = '+St2+
  910.                '|ITERATIONS = '+St3+
  911.                '|MODULE NUMBER = '+St4+
  912.                '|MODULE NAME = '+T[Num].Name+
  913.                '|QTT POINTS = '+St5+'|',
  914.                '_I KNOW !|',Result);
  915.    End Else ERROR_11;                   {*Can't Save*}
  916. End;
  917.  
  918. {╔═══════════════════════════════════════════════════════════════════════════╗
  919.  ║                         - AFFICHAGE DE LA GRILLE -                        ║
  920.  ╠═══════════════════════════════════════════════════════════════════════════╣
  921.  ║ IN.....: /                                                                ║
  922.  ║ OUT....: /                                                                ║
  923.  ║ EXPLAIN: Affiche la Grille dans la Fenêtre Graphique.                     ║
  924.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  925.  
  926. Procedure DRAW_GRID(W:Win);
  927. Var X1,Y1,X2,Y2:Integer;                {*Coordonées du Repère*}
  928.     A:Integer;
  929.  
  930. Begin
  931. Grid:=True;
  932. COORDONEES_REPERE(W,X1,Y1,X2,Y2);       {*Calcule Coordonée du Repère*}
  933. SetColor(Col1);
  934. HideMouse; A:=0;                        {*Init Data*}
  935. Repeat
  936. If A Mod 10=0 Then Line(X1+A*3,Y2,X1+A*3,Y1-4); {*Draw Repère Horizontal*}
  937. Inc(A);
  938. Until X1+A*3>X2;
  939.  
  940. A:=0;
  941. Repeat
  942. If A Mod 10=0 Then Line(X1+4,Y1-A*2,X2,Y1-A*2); {*Draw Repère Vertical*}
  943. Inc(A);
  944. Until Y1-A*2<Y2;
  945. ShowMouse;
  946. End;
  947.  
  948. {╔═══════════════════════════════════════════════════════════════════════════╗
  949.  ║                  - AFFICHAGE OU SUPRESSION DE LA GRILLE -                 ║
  950.  ╠═══════════════════════════════════════════════════════════════════════════╣
  951.  ║ IN.....: /                                                                ║
  952.  ║ OUT....: /                                                                ║
  953.  ║ EXPLAIN: Affiche ou Suprime la Grille dans la Fenêtre Graphique.          ║
  954.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  955.  
  956. Procedure UPDATE_GRID(Num:Integer; W:Win);
  957. Begin
  958. AFF(23);                                {*Display Help on Gadgets*}
  959. If NoClear=False Then CLEAR_WINDOW(W);  {*Redraw All*}
  960. DRAW_REPERE(Num,W);
  961.  
  962. If Grid=True Then Grid:=False           {*Grid is "Off"*}
  963.    Else Begin DRAW_GRID(W);             {*Grid is "On"*}
  964.    Grid:=True; End;
  965.  
  966. DRAW_COURBE(Num,W);
  967. End;
  968.  
  969. {╔═══════════════════════════════════════════════════════════════════════════╗
  970.  ║                        - SWAP BEETWEEN TIME/RATE -                        ║
  971.  ╠═══════════════════════════════════════════════════════════════════════════╣
  972.  ║ IN.....: /                                                                ║
  973.  ║ OUT....: /                                                                ║
  974.  ║ EXPLAIN: Affiche en Ordonnée soit le Temps, soit le Taux de Transfert.    ║
  975.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  976.  
  977. Procedure UPDATE_ORDONEE(Num:Integer; Var W4:Win);
  978. Var A:Integer;                            {*Pour la Boucle*}
  979.  
  980. Begin
  981. AFF(21);                                  {*Help on Gadgets*}
  982. If Disp_Rate=False Then
  983.    Begin
  984.    Disp_Rate:=True;
  985.    RENAME_WINDOW('DRAWING TRANSFERT RATE FOR MODULE '+T[Num].Name,W4);
  986.    For A:=1 to Qtt_Points do              {*Convertit Temps en Rate*}
  987.        If P[A]<>0 Then P[A]:=(Freq*(T[Num].Length Div 1024)) Div P[A];
  988.    End
  989.  
  990.    Else Begin
  991.    Disp_Rate:=False;
  992.    RENAME_WINDOW('DRAWING SPEED WRITING FOR MODULE '+T[Num].Name,W4);
  993.    For A:=1 to Qtt_Points do              {*Convertit Rate en Temps*}
  994.        If P[A]<>0 Then P[A]:=(Freq*(T[Num].Length Div 1024)) Div P[A];
  995.    End;
  996.  
  997. If NoClear=False Then CLEAR_WINDOW(W4); {*Redraw All*}
  998. DRAW_REPERE(Num,W4);
  999. If Grid=True Then DRAW_GRID(W4);        {*Grid is "On"*}
  1000. DRAW_COURBE(Num,W4);
  1001. End;
  1002.  
  1003. {╔═══════════════════════════════════════════════════════════════════════════╗
  1004.  ║                      - EXECUTION DU MODULE PASCAL -                       ║
  1005.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1006.  ║ IN.....: /                                                                ║
  1007.  ║ OUT....: /                                                                ║
  1008.  ║ EXPLAIN: Execute l'Ecriture par le Module PASCAL.                         ║
  1009.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1010.  
  1011. Procedure OPEN_PASCAL_FILE;
  1012. Begin
  1013. Assign(PasFile,'DSTEST.BIN');           {*Try to Rewrite "DSTEST.BIN"*}
  1014. {$I-}
  1015. Rewrite(PasFile,1);                     {*Open It*}
  1016. {$I+}
  1017. If IOResult<>0 Then DOS_Error:=1;       {*Teste les Erreurs...*}
  1018. End;
  1019.  
  1020. Procedure CLOSE_PASCAL_FILE;            {*Ferme le Fichier PASCAL*}
  1021. Begin
  1022. Close(PasFile);
  1023. End;
  1024.  
  1025. Procedure DELETE_PASCAL_FILE;           {*Suprime le Fichier Pascal*}
  1026. Begin
  1027. Erase(PasFile);
  1028. End;
  1029.  
  1030. Procedure WRITE_PASCAL_FILE(Var NBO:Word);{*Ecrit les Données*}
  1031. Var NB:Word;
  1032. Begin
  1033. BlockWrite(PasFile,NB,NBO,Nb);           {*Write les Datas à Partir de "P"*}
  1034. If Nb<>NBO Then DOS_Error:=1;
  1035. NBO:=NB;                                 {*Transmet la Taille Ecrite*}
  1036. End;
  1037.  
  1038. {╔═══════════════════════════════════════════════════════════════════════════╗
  1039.  ║                     - EXECUTION DU MODULE ASM DOS -                       ║
  1040.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1041.  ║ IN.....: /                                                                ║
  1042.  ║ OUT....: /                                                                ║
  1043.  ║ EXPLAIN: Execute l'Ecriture par le Module ASM DOS.                        ║
  1044.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1045.  
  1046. {╔═══════════════════════════════════════════════════════════════════════════╗
  1047.  ║                          PROCEDURE GET_DOS_ERROR                          ║
  1048.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1049.  ║ IN.....: /                                                                ║
  1050.  ║ OUT....: NUM (BYTE) = Numéro de l'Erreur.                                 ║
  1051.  ║ EXPLAIN: Recupere le Numéro de la Derniere Erreur Produite,               ║
  1052.  ║          Ainsi que Diverse info à son Sujet.                              ║
  1053.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1054.  
  1055. Procedure GET_DOS_ERROR; Assembler;
  1056. Asm
  1057. Push Bx
  1058. Push Ax
  1059. Mov  Ah,$59
  1060. Mov  Bx,$00
  1061. Int  $21
  1062. Mov  DOS_Error,Ax                       {*Numéro de l'Erreur DOS*}
  1063. Mov  DOS_Class_Error,Bh                 {*Le Pourquoi de l'Erreur*}
  1064. Mov  DOS_Correct_Error,Bl               {*Comment y Remedier*}
  1065. Mov  DOS_Local_Error,Ch                 {*Sa Localisation*}
  1066. Pop  Ax
  1067. Pop  Bx
  1068. End;
  1069.  
  1070. {╔═══════════════════════════════════════════════════════════════════════════╗
  1071.  ║                        PROCEDURE OPEN_DOS_FILE                            ║
  1072.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1073.  ║ IN.....: /                                                                ║
  1074.  ║ OUT....: /                                                                ║
  1075.  ║ EXPLAIN: Ouvre en Ecriture le Fichier "DSTEST.BIN".                       ║
  1076.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1077.  
  1078. Procedure OPEN_DOS_FILE;
  1079. Begin
  1080. Asm
  1081. @START:
  1082.    Jmp  @BEGIN                          {*Skip Datas*}
  1083.  
  1084. @FileName: DB 'DSTEST.BIN',0            {*Path + Nom Fichier*}
  1085.  
  1086. @BEGIN:
  1087.    Mov  DOS_ERROR,0                     {*Clear Var Errors Détections*}
  1088.    Mov  DOS_Class_Error,0
  1089.    Mov  DOS_Correct_Error,0
  1090.    Mov  DOS_Local_Error,0
  1091.  
  1092.    Push Dx
  1093.    Push Ax
  1094.    Push Ds
  1095.    Mov  Ax,Seg @FileName
  1096.    Mov  Ds,Ax
  1097.    Mov  Dx,Offset @FileName             {*Pointeur sur Nom*}
  1098.    Mov  Al,$02                          {*Ouverture en Lecture/Ecriture*}
  1099.    Mov  Ah,$3D                          {*Only Open File With Handle*}
  1100.    Int  $21                             {*Go !!!*}
  1101.  
  1102.    Jnc   @EXIT                          {*Si tout est Ok => Go to Fin*}
  1103.    Mov   DOS_ERROR,$-1                  {*On Signale 1 Erreur à Traiter*}
  1104.  
  1105. @EXIT:                                  {*The End*}
  1106.    Pop  Ds
  1107.    Mov  Handle,Ax                       {*Recupère le Handle*}
  1108.    Pop  Ax
  1109.    Pop  Dx
  1110.  
  1111. @GOTODEBUT:                             {*Positionnement Début Fichier*}
  1112.    Push Bx
  1113.    Push Cx
  1114.    Push Dx
  1115.    Mov  Ah,$42
  1116.    Mov  Al,$00
  1117.    Mov  Bx,Handle
  1118.    Mov  Cx,0
  1119.    Mov  Dx,0
  1120.    int  $21                             {*Go !!!*}
  1121.    Pop  Dx
  1122.    Pop  Cx
  1123.    Pop  Bx
  1124.  
  1125. End;
  1126. If DOS_ERROR<>0 Then
  1127.    Begin
  1128.    GET_DOS_ERROR;                       {*Récupère Numéro de l'Erreur*}
  1129.    DISPLAY_DOS_ERROR;                   {*Affiche Erreur*}
  1130.    End;
  1131. End;
  1132.  
  1133. {╔═══════════════════════════════════════════════════════════════════════════╗
  1134.  ║                        PROCEDURE CREATE_DOS_FILE                          ║
  1135.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1136.  ║ IN.....: /                                                                ║
  1137.  ║ OUT....: /                                                                ║
  1138.  ║ EXPLAIN: Crée et Ouvre en Ecriture le Fichier "DSTEST.BIN".               ║
  1139.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1140.  
  1141. Procedure CREATE_DOS_FILE;
  1142. Begin
  1143. Asm
  1144. @START:
  1145.    Jmp  @BEGIN                          {*Skip Datas*}
  1146.  
  1147. @FileName: DB 'DSTEST.BIN',0            {*Path + Nom Fichier*}
  1148.  
  1149. @BEGIN:
  1150.    Mov  DOS_ERROR,0                     {*Clear Var Errors Détections*}
  1151.    Mov  DOS_Class_Error,0
  1152.    Mov  DOS_Correct_Error,0
  1153.    Mov  DOS_Local_Error,0
  1154.  
  1155.    Push Cx
  1156.    Push Dx
  1157.    Push Ax
  1158.    Push Ds
  1159.    Mov  Cx,$00                          {*Attribut. $00 = Archive*}
  1160.    Mov  Ax,Seg @FileName
  1161.    Mov  Ds,Ax
  1162.    Mov  Dx,Offset @FileName             {*Pointeur sur Nom*}
  1163.    Mov  Ah,$3C                          {*Function Create File With Handle*}
  1164.    Int  $21                             {*Create File*}
  1165.  
  1166.    Jnc   @EXIT1                         {*Si tout est Ok => Go to Fin*}
  1167.    Mov   DOS_ERROR,$-1                  {*On Signale 1 Erreur à Traiter*}
  1168.  
  1169. @EXIT1:                                 {*The End*}
  1170.    Pop  Ds
  1171.    Mov  Handle,Ax                       {*Recupère le Handle*}
  1172.    Pop  Ax
  1173.    Pop  Dx
  1174.    Pop  Cx
  1175. End;
  1176. If DOS_ERROR<>0 Then
  1177.    Begin
  1178.    GET_DOS_ERROR;                       {*Récupère Numéro de l'Erreur*}
  1179.    DISPLAY_DOS_ERROR;                   {*Affiche Erreur*}
  1180.    End;
  1181. End;
  1182.  
  1183. {╔═══════════════════════════════════════════════════════════════════════════╗
  1184.  ║                         PROCEDURE CLOSE_DOS_FILE                          ║
  1185.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1186.  ║ IN.....: /                                                                ║
  1187.  ║ OUT....: /                                                                ║
  1188.  ║ EXPLAIN: Ferme le Fichier Ouvert par OPEN_DOS_FILE.                       ║
  1189.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1190.  
  1191. Procedure CLOSE_DOS_FILE;
  1192. Begin
  1193. Asm
  1194.    Push Bx
  1195.    Mov  Ah,$3E                          {*Function Close File*}
  1196.    Mov  Bx,Handle                       {*Handle Fichier*}
  1197.    Int  $21                             {*Create File*}
  1198.    Pop  Bx
  1199.  
  1200.    Jnc   @EXIT                          {*Si tout est Ok => Go to Fin*}
  1201.    Mov   DOS_ERROR,$-1                  {*On Signale 1 Erreur à Traiter*}
  1202.  
  1203. @EXIT:                                  {*The End*}
  1204. End;
  1205. If DOS_ERROR<>0 Then
  1206.    Begin
  1207.    GET_DOS_ERROR;                       {*Récupère Numéro de l'Erreur*}
  1208.    DISPLAY_DOS_ERROR;                   {*Affiche Erreur*}
  1209.    End;
  1210. End;
  1211.  
  1212. {╔═══════════════════════════════════════════════════════════════════════════╗
  1213.  ║                        PROCEDURE DELETE_DOS_FILE                          ║
  1214.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1215.  ║ IN.....: /                                                                ║
  1216.  ║ OUT....: /                                                                ║
  1217.  ║ EXPLAIN: Suprime le Fichier Créé par OPEN_DOS_FILE.                       ║
  1218.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1219.  
  1220. Procedure DELETE_DOS_FILE;
  1221. Begin
  1222. Asm
  1223. @START:
  1224.    Jmp  @BEGIN
  1225. @FileName: DB 'DSTEST.BIN',0            {*Path + Nom Fichier*}
  1226.  
  1227. @BEGIN:
  1228.    Push Ds
  1229.    Push Dx
  1230.    Push Ax
  1231.    Mov  Ax,Seg @FileName
  1232.    Mov  Ds,Ax
  1233.    Mov  Dx,Offset @FileName             {*Pointeur Path + Nom Fichier*}
  1234.    Mov  Ah,$41                          {*Function Delete File*}
  1235.    Int  $21                             {*Delete File*}
  1236.    Pop  Ax
  1237.    Pop  Dx
  1238.    Pop  Ds
  1239.  
  1240.    Jnc   @EXIT                          {*Si tout est Ok => Go to Fin*}
  1241.    Mov   DOS_ERROR,$-1                  {*On Signale 1 Erreur à Traiter*}
  1242.  
  1243. @EXIT:                                  {*The End*}
  1244. End;
  1245. If DOS_ERROR<>0 Then
  1246.    Begin
  1247.    GET_DOS_ERROR;                       {*Récupère Numéro de l'Erreur*}
  1248.    DISPLAY_DOS_ERROR;                   {*Affiche Erreur*}
  1249.    End;
  1250. End;
  1251.  
  1252. {╔═══════════════════════════════════════════════════════════════════════════╗
  1253.  ║                         PROCEDURE WRITE_DOS_FILE                          ║
  1254.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1255.  ║ IN.....: /                                                                ║
  1256.  ║ OUT....: /                                                                ║
  1257.  ║ EXPLAIN: Ecrit Des Données Quelconques dans le Fichier.                   ║
  1258.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1259.  
  1260. Procedure WRITE_DOS_FILE(Var NBO:Word);
  1261. Var NB:Word;
  1262.  
  1263. Begin
  1264. NB:=NBO;                                {*Transmet la Taille à Ecrire*}
  1265. Asm
  1266. @BEGIN:
  1267.    Push Bx
  1268.    Push Ax
  1269.    Push Ds
  1270.    Push Cx
  1271.    Mov  Bx,Handle                       {*Handle Fichier*}
  1272.    Mov  Cx,NB                           {*Nombre d'Octets à Ecrire*}
  1273.    Mov  Ax,Seg @BEGIN
  1274.    Mov  Ds,Ax
  1275.    Mov  Dx,Offset @BEGIN                {*Adr des Datas à Ecrire*}
  1276.    Mov  Ah,$40                          {*Function Write in File*}
  1277.    Int  $21                             {*Create File*}
  1278.  
  1279.    Jnc   @EXIT                          {*Si tout est Ok => Go to Fin*}
  1280.    Mov   DOS_ERROR,$-1                  {*On Signale 1 Erreur à Traiter*}
  1281.  
  1282. @EXIT:                                  {*The End*}
  1283.    Pop  Cx
  1284.    Pop  Ds
  1285.    Mov  NB,Ax                           {*Recupère Nb Octets Ecrits*}
  1286.    Pop  Ax
  1287.    Pop  Bx
  1288. End;
  1289. If DOS_ERROR<>0 Then
  1290.    Begin
  1291.    GET_DOS_ERROR;                       {*Récupère Numéro de l'Erreur*}
  1292.    DISPLAY_DOS_ERROR;                   {*Affiche Erreur*}
  1293.    End;
  1294. NBO:=NB;                                {*Renvois Nb Octets Ecrits*}
  1295. End;
  1296.  
  1297. {╔═══════════════════════════════════════════════════════════════════════════╗
  1298.  ║                    - EXECUTION DU MODULE TRACK I26 -                      ║
  1299.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1300.  ║ IN.....: /                                                                ║
  1301.  ║ OUT....: /                                                                ║
  1302.  ║ EXPLAIN: Execute l'Ecriture par le Module Track Interruption 26.          ║
  1303.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1304.  
  1305. Procedure WRITE_TRACKS_I26(Var NBO:Word; NumDisk:Byte);
  1306. Var NbS:Longint;                {*Nombre de Secteurs Calculés*}
  1307.     Ite:Word;                   {*Nb d'itérations de 128 Secteurs à Faire*}
  1308.     Rest:Word;                  {*Reste des Secteurs à Ecrire Aprés la Boucle*}
  1309.     A  :Word;                   {*Variable de Boucle pour Itération*}
  1310.  
  1311. Procedure WRITE_ASM_DOS_TRACK_REAL(NbSecteurs:Word); Assembler;
  1312. Asm                             {*Partie Assembleur*}
  1313. @BEGIN: Push Ax                 {*Sauvegarde Registres à la Con !!!*}
  1314.         Push Bx
  1315.         Push Cx
  1316.         Push Ds
  1317.         Mov Al,NumDisk          {*Numéro du Disque où écrire*}
  1318.         Mov Ax,Seg @BEGIN       {*Adresse des Datas à écrire*}
  1319.         Mov Ds,Ax
  1320.         Mov Bx,Offset @BEGIN
  1321.         Mov Cx,NbSecteurs       {*Nombre de Secteurs à écrire*}
  1322.         Mov Dx,0                {*Premier Secteur = Boot*}
  1323.         Int $26                 {*Appel Ecriture*}
  1324.         Popf                    {*Désempile Flags à cause du RET et pas IRET*}
  1325.  
  1326.         jnc @EXIT               {*No Carry = Ok => go to @EXIT*}
  1327.         Mov DOS_ERROR,$-1       {*On Signale une Erreur !*}
  1328.  
  1329. @EXIT:  Pop Ax                  {*Restore Registres Toujours à la Con !!!*}
  1330.         Pop Bx
  1331.         Pop Cx
  1332.         Pop Ds
  1333. End;
  1334.  
  1335. {**************** PROCEDURE PRINCIPALE DE CALCUL DES TRACKS *****************}
  1336.  
  1337. Begin
  1338. NbS:=NBO Div 1024;              {*Calcul des Secteurs*}
  1339. If NBO Mod NbS<>0 Then Inc(NbS);{*Majore de 1 Secteurs Suplémentaire*}
  1340. Ite:=NbS Div 128;               {*Calcul du nombre d'Itérations*}
  1341. Rest:=NbS-(Ite*128);            {*Reste des Secteurs à Ecrire Aprés la Boucle*}
  1342. DOS_ERROR:=0;                   {*Annulation Flag d'erreur*}
  1343.  
  1344. If Ite=0 Then WRITE_ASM_DOS_TRACK_REAL(Rest){*Write Less Than 128 Blocks*}
  1345.    Else Begin
  1346.    For A:=1 to Ite do           {*Boucle d'Itérations des Blocks de 128 Secteurs*}
  1347.        WRITE_ASM_DOS_TRACK_REAL(128);{*Write Real Tracks per 128 Blocks long*}
  1348.    WRITE_ASM_DOS_TRACK_REAL(Rest){*Write the Rest*}
  1349.    End;
  1350.  
  1351. If DOS_ERROR<>0 Then            {*Error During Writing ?*}
  1352.    Begin
  1353.    GET_DOS_ERROR;               {*Récupère et Affiche Erreur du DOS*}
  1354.    DISPLAY_DOS_ERROR;
  1355.    End;
  1356. End;
  1357.  
  1358. {╔═══════════════════════════════════════════════════════════════════════════╗
  1359.  ║                - CONFIGURATION DES PARAMETRES DES MODULES -               ║
  1360.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1361.  ║ IN.....: /                                                                ║
  1362.  ║ OUT....: FIL1 (TEXT): Fichier Texte Eventuellement Modifié.               ║
  1363.  ║ EXPLAIN: Affiche les Datas des Différents Modules, et Permet de les Modif.║
  1364.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1365.  
  1366. {************************** AFFICHAGE DU SCREEN ****************************}
  1367.  
  1368. Procedure PARAMETERS_MODULES;
  1369. Var W       :Win;
  1370.     B0,B1,B2:ButG;                      {*Gadgets Buttons*}
  1371.     B3      :ButG;
  1372.     C1      :ButG;                      {*Gadget Cycler*}
  1373.     Exit_Flg:Boolean;
  1374.     Even    :Byte;                      {*Evenement Fenêtre*}
  1375.     DirSel  :String;                    {*Datas Fichiers*}
  1376.     FilSel  :String;
  1377.     FSize   :Longint;
  1378.     Fil1    :Text;                      {*Fichier Texte des Datas Modules*}
  1379.     NUM     :Integer;
  1380.     P       :Byte;                      {*Nb De Modules Lus*}
  1381.     HasChanged:Boolean;                 {*Modifications Pour Sauvegarde*}
  1382.  
  1383.     Cor1,Cor2,Cor3,Cor4,Cor5,
  1384.     Cor6,Cor7,Cor8,Cor9,CorA:TCoReq;
  1385.     Cin1,Cin2,Cin3,Cin4,Cin5,
  1386.     Cin6,Cin7,Cin8,Cin9,CinA,
  1387.     CinB,CinC,CinD:String;
  1388.  
  1389. {╔═══════════════════════════════════════════════════════════════════════════╗
  1390.  ║                  - SAUVEGARDE DES DATAS DES MODULES -                     ║
  1391.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1392.  
  1393. Procedure SAVE_NEW_DATAS;
  1394. Var A:Integer;
  1395.  
  1396. Begin
  1397. HasChanged:=False;                      {*Update Has Been Made !!!*}
  1398.  
  1399. Assign(Fil1,'DSMODULE.DTA');
  1400. {$I-}
  1401. Rewrite(Fil1);                          {*Open to Write...*}
  1402. {$I+}
  1403. If IOResult=0 Then                      {*Teste les Erreurs...*}
  1404.    Begin
  1405.    For A:=1 to NbModules do
  1406.       Begin
  1407.       Writeln(Fil1,'************************************');
  1408.       Writeln(Fil1,'');
  1409.       Writeln(Fil1,T[A].Name);                 {*Save Labels*}
  1410.       Writeln(Fil1,T[A].FName);
  1411.       Writeln(Fil1,T[A].FPath);
  1412.       Writeln(Fil1,T[A].Fragment);
  1413.       Writeln(Fil1,T[A].Length);
  1414.       Writeln(Fil1,T[A].Buffer);
  1415.       Writeln(Fil1,T[A].System);
  1416.       Writeln(Fil1,T[A].Algo);
  1417.       Writeln(Fil1,T[A].StatusMod);
  1418.       Writeln(Fil1,T[A].Number);
  1419.       Writeln(Fil1,T[A].Time);
  1420.       Writeln(Fil1,T[A].Rate);
  1421.       Writeln(Fil1,T[A].BRate);
  1422.       Writeln(Fil1,T[A].WRate);
  1423.       Writeln(Fil1,T[A].Comments);              {*Save Comments*}
  1424.       Writeln(Fil1,'');                         {*Skip Blank Line*}
  1425.       End;
  1426.    Close(Fil1);
  1427.    End
  1428.    Else ERROR_03;                               {*Error Saving !*}
  1429. End;
  1430.  
  1431. {╔═══════════════════════════════════════════════════════════════════════════╗
  1432.  ║                     - AFFICHAGE DES DATAS MODULES -                       ║
  1433.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1434.  
  1435. Procedure REDRAW_DATAS;
  1436. Begin
  1437. Cin1:=T[P].Name;
  1438. Cin2:=T[P].FName;
  1439. Cin3:=T[P].Fragment;
  1440. Str(T[P].Length,Cin4);
  1441. Str(T[P].Buffer,Cin5);
  1442. Cin6:=T[P].System;
  1443. Cin7:=T[P].Algo;
  1444. Cin8:=T[P].StatusMod;
  1445. Str(T[P].Number,Cin9);
  1446. Str(T[P].Time,CinA);
  1447. Str(T[P].Rate,CinB);
  1448. Str(T[P].BRate,CinC);
  1449. Str(T[P].WRate,CinD);
  1450.  
  1451. HideMouse;
  1452. Bevel(W.X1+185,W.Y1+15+HaF*1,W.X1+265,W.Y1+19+HaF*2,1,12,False,True);
  1453. Bevel(W.X1+245,W.Y1+23+HaF*2,W.X1+265,W.Y1+27+HaF*3,1,12,False,True);
  1454. Bevel(W.X1+185,W.Y1+31+HaF*3,W.X1+265,W.Y1+35+HaF*4,1,12,False,True);
  1455. Bevel(W.X1+185,W.Y1+39+HaF*4,W.X1+265,W.Y1+43+HaF*5,1,12,False,True);
  1456. Bevel(W.X1+185,W.Y1+47+HaF*5,W.X1+265,W.Y1+51+HaF*6,1,12,False,True);
  1457. Bevel(W.X1+185,W.Y1+55+HaF*6,W.X1+265,W.Y1+59+HaF*7,1,12,False,True);
  1458.  
  1459. DRAW_CO_REQUESTG(W.X1+15,W.Y1+15+HaF*1,79,16,6,1,Cor1,Cin1);
  1460. DRAW_CO_REQUESTG(W.X1+15,W.Y1+23+HaF*2,79,16,6,1,Cor2,Cin2);
  1461. DRAW_CO_REQUESTG(W.X1+15,W.Y1+31+HaF*3,79,16,6,1,Cor3,Cin3);
  1462. DRAW_CO_REQUESTG(W.X1+30,W.Y1+39+HaF*4,64,16,6,1,Cor4,Cin4);
  1463. DRAW_CO_REQUESTG(W.X1+30,W.Y1+47+HaF*5,64,16,6,1,Cor5,Cin5);
  1464. DRAW_CO_REQUESTG(W.X1+15,W.Y1+55+HaF*6,79,16,6,1,Cor6,Cin6);
  1465. DRAW_CO_REQUESTG(W.X1+15,W.Y1+63+HaF*7,79,16,6,1,Cor7,Cin7);
  1466.  
  1467. DispG(W.X1+190,W.Y1+16+HaF*1,12,Cin8);
  1468. DispG(W.X1+250,W.Y1+24+HaF*2,12,Cin9);
  1469. DispG(W.X1+190,W.Y1+32+HaF*3,12,CinA+' 1/1000s');
  1470. DispG(W.X1+190,W.Y1+40+HaF*4,12,CinB+' Kb/s');
  1471. DispG(W.X1+190,W.Y1+48+HaF*5,12,CinC+' Kb/s');
  1472. DispG(W.X1+190,W.Y1+56+HaF*6,12,CinD+' Kb/s');
  1473. ShowMouse;
  1474. End;
  1475.  
  1476. {╔═══════════════════════════════════════════════════════════════════════════╗
  1477.  ║               - UPDATE DES DATAS DES MODULES EN MEMOIRE -                 ║
  1478.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1479.  
  1480. Procedure UPDATE_VALUES;
  1481. Var I,Code:Integer;
  1482.     Save_Length, Save_Buffer:Longint;           {*Save Values for UNDO*}
  1483. Begin
  1484. Save_Length:=T[P].Length;                       {*Save Values*}
  1485. Save_Buffer:=T[P].Buffer;
  1486.  
  1487. T[P].Name:=Cin1;
  1488. T[P].FName:=Cin2;
  1489. T[P].Fragment:=Cin3;
  1490. Val(Cin4,T[P].Length,Code);
  1491. Val(Cin5,T[P].Buffer,Code);
  1492. T[P].System:=Cin6;
  1493. T[P].Algo:=Cin7;
  1494. T[P].StatusMod:=Cin8;
  1495. Val(Cin9,T[P].Number,Code);
  1496. Val(CinA,T[P].Time,Code);
  1497. Val(CinB,T[P].Rate,Code);
  1498. Val(CinC,T[P].BRate,Code);
  1499. Val(CinD,T[P].WRate,Code);
  1500.  
  1501. If (T[P].Buffer=0)Or (T[P].Length=0) Then
  1502.    Begin
  1503.    ERROR_12;                                       {*Size or Buffer = 0 !!!*}
  1504.    T[P].Length:=Save_Length;                       {*Restore Good Values*}
  1505.    T[P].Buffer:=Save_Buffer;
  1506.    End;
  1507.  
  1508. If (T[P].Buffer>34464) And (P=3) Then              {*For Asm DOS Only*}
  1509.    Begin
  1510.    ERROR_10;                                       {*File Buffer too Large*}
  1511.    T[P].Buffer:=Save_Buffer;                       {*Restore Good Value*}
  1512.    End;
  1513.  
  1514. If T[P].Buffer>65535 Then
  1515.    Begin
  1516.    ERROR_13;                                       {*File Buffer too Large*}
  1517.    T[P].Buffer:=Save_Buffer;                       {*Restore Good Value*}
  1518.    End;
  1519.  
  1520. If T[P].Buffer>T[P].Length Then
  1521.    Begin
  1522.    ERROR_04;                                       {*File Buffer Higher Len*}
  1523.    T[P].Length:=Save_Length;                       {*Restore Good Values*}
  1524.    T[P].Buffer:=Save_Buffer;
  1525.    End;
  1526.  
  1527. REDRAW_DATAS;                                      {*Réaffiche le Screen*}
  1528. HasChanged:=True;
  1529. End;
  1530.  
  1531. {╔═══════════════════════════════════════════════════════════════════════════╗
  1532.  ║                    - AFFICHAGE DU SCREEN PRINCIPAL -                      ║
  1533.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1534.  
  1535. Procedure REDRAW_FRAME;
  1536. Begin
  1537. HideMouse;
  1538. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  1539. ButtonG(W.X1+26,W.Y2-10-HaF,70,False,B0,'_OK'); {*Bouton SAVE,USE,CANCEL*}
  1540. ButtonG(W.X1+274,W.Y2-10-HaF,70,False,B1,'_CANCEL');
  1541. ButtonG(W.X1+185,W.Y2-34-HaF*1,159,False,B3,'_EDIT MODULE COMMENTS');
  1542. Cycler_But(W.X1+132,W.Y2-10-HaF,87,P,C1,Modules);
  1543.  
  1544. SetColor(Col0);
  1545. DispG(W.X1+100,W.Y1+16+HaF*1,7,'MODULE NAME');
  1546. ButtonG(W.X1+100,W.Y1+23+HaF*2,70,False,B2,'_FILE NAME');
  1547. DispG(W.X1+100,W.Y1+32+HaF*3,7,'FILE STATUS');
  1548. DispG(W.X1+100,W.Y1+40+HaF*4,7,'FILE LENGTH');
  1549. DispG(W.X1+100,W.Y1+48+HaF*5,7,'SIZE BUFFER');
  1550. DispG(W.X1+100,W.Y1+56+HaF*6,7,'USED SYSTEM');
  1551. DispG(W.X1+100,W.Y1+64+HaF*7,7,'ALGORITHM');
  1552.  
  1553. DispG(W.X1+270,W.Y1+16+HaF*1,7,'MODULE STATUS');
  1554. DispG(W.X1+270,W.Y1+24+HaF*2,7,'MODULE NUMBER');
  1555. DispG(W.X1+270,W.Y1+32+HaF*3,7,'WRITING TIME');
  1556. DispG(W.X1+270,W.Y1+40+HaF*4,7,'TRANSFERT RATE');
  1557. DispG(W.X1+270,W.Y1+48+HaF*5,7,'BEST RATE');
  1558. DispG(W.X1+270,W.Y1+56+HaF*6,7,'WORSE RATE');
  1559.  
  1560. REDRAW_DATAS;                              {*Affiche Datas Modules*}
  1561. ShowMouse;
  1562. End;
  1563.  
  1564. {╔═══════════════════════════════════════════════════════════════════════════╗
  1565.  ║                    - MODIFICATION DES COMMENTAIRES-                       ║
  1566.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1567.  
  1568. Procedure MODIF_COMMENTS;
  1569. Var NUM:Integer;
  1570.     St :String;
  1571. Begin
  1572. St:=T[P].Comments;
  1573. STRING_REQUESTG('D-SPEED REQUEST',
  1574.                 'PLEASE MODIFIE COMMENTS FOR MODULE '''+T[P].Name+'''||PRESS ''OK'' TO CONFIRM|',
  1575.                 ' _OK |_CANCEL|',64,390,St,NUM);
  1576. If NUM=1 Then
  1577.    Begin
  1578.    HasChanged:=True;            {*For Save if Quit with "Ok"*}
  1579.    T[P].Comments:=St;           {*Modifie Comments*}
  1580.    End;
  1581. End;
  1582.  
  1583. {***************************** MAIN PROCEDURE ******************************}
  1584.  
  1585. Begin
  1586. AFF(11);                                   {*Display Help on Gadgets*}
  1587. If Modules='|'Then
  1588.    Begin
  1589.    ERROR_01; Exit;                         {*List is Empty*}
  1590.    End;
  1591. INIT_WINDOW(100,70,470,148+HaF*10,$51D9,'CONFIGURATION PARAMETERS MODULES',W);
  1592. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0004,W);
  1593. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  1594.  
  1595. P:=1;                                      {*Premier Module*}
  1596. HasChanged:=False;
  1597. DRAW_WINDOW(W);                            {*Affiche Screen Principal*}
  1598. REDRAW_FRAME;                              {*Affiche Gadgets*}
  1599. Exit_Flg:=False;
  1600.                 {=== BOUCLE PRINCIPALE ===}
  1601. Repeat
  1602. If WINDOW_READY(W) Then                    {*Window Ok !*}
  1603.    Begin
  1604.  
  1605.    If CO_REQUESTG(Cor1,Cin1)=True Then UPDATE_VALUES;{*Co_RequestG String-Line*}
  1606.    If CO_REQUESTG(Cor2,Cin2)=True Then UPDATE_VALUES;
  1607.    If CO_REQUESTG(Cor3,Cin3)=True Then UPDATE_VALUES;
  1608.    If CO_REQUESTG(Cor4,Cin4)=True Then UPDATE_VALUES;
  1609.    If CO_REQUESTG(Cor5,Cin5)=True Then UPDATE_VALUES;
  1610.    If CO_REQUESTG(Cor6,Cin6)=True Then UPDATE_VALUES;
  1611.    If CO_REQUESTG(Cor7,Cin7)=True Then UPDATE_VALUES;
  1612.  
  1613.    If GetMsg_But(B0,1)=True Then
  1614.       Begin
  1615.       Exit_Flg:=True;
  1616.       If HasChanged=True Then
  1617.          EZ_REQUESTG('D-SPEED REQUEST',
  1618.          'DATAS HAS BEEN CHANGED,|SO, DO YOU WANT TO UPDATE AND SAVE DATAS ?|',
  1619.          '_YES|_NO|',NUM);
  1620.       If NUM=1 Then SAVE_NEW_DATAS;
  1621.       End;
  1622.  
  1623.    If GetMsg_But(B1,1)=True Then Exit_Flg:=True;
  1624.    If GetMsg_But(B2,1)=True Then Begin
  1625.       AFF(12);                             {*Display Help on Gadgets*}
  1626.       GET_FILEDIR(250,50,300,'SELECT A MODULE...','_SELECT','*.*',0,DirSel,FilSel,FSize);
  1627.       If FilSel<>'' Then Begin
  1628.          HasChanged:=True;                 {*Save Modif*}
  1629.          T[P].FName:=FilSel;               {*Stocke New Values*}
  1630.          T[P].FPath:=DirSel;
  1631.          Cin2:=DirSel+FilSel;              {*Transmet New Path+Name*}
  1632.          DRAW_CO_REQUESTG(W.X1+15,W.Y1+23+HaF*2,79,16,6,1,Cor2,Cin2);
  1633.          End;
  1634.       End;
  1635.    If GetMsg_But(B3,1)=True Then Begin AFF(13); MODIF_COMMENTS; End;
  1636.    If GetMsg_But(C1,1)=True Then Begin AFF(14); P:=C1.CyclVal; REDRAW_DATAS; End;
  1637.    End;
  1638.  
  1639. Even:=Active_Window(W);
  1640. If Even=9 Then REDRAW_FRAME;               {*Window Re-Drawed*}
  1641. If Even=1 Then Exit_Flg:=True;             {*Window Closed*}
  1642. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  1643. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  1644. Until Exit_Flg=True;                       {*Sortie de la Boucle*}
  1645.  
  1646. Kill_Window(W);                            {*Destroy Window*}
  1647. End;
  1648.  
  1649. {╔═══════════════════════════════════════════════════════════════════════════╗
  1650.  ║                       - CONFIGURATION DES MODULES -                       ║
  1651.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1652.  ║ IN.....: /                                                                ║
  1653.  ║ OUT....: FIL1 (TEXT): Fichier Texte Eventuellement Modifié.               ║
  1654.  ║ EXPLAIN: Permet de Rajouter un Module dans la Liste des Modules.          ║
  1655.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1656.  
  1657. Procedure CONFIGURE_MODULES;
  1658. Var W       :Win;
  1659.     B0,B1,B2,                              {*Boutons Gadgets*}
  1660.     B3,B4   :ButG;
  1661.     C0      :ButG;                         {*Boutons Cycler*}
  1662.     Exit_Flg:Boolean;
  1663.     Even    :Byte;                         {*Evenement Window*}
  1664.     St      :String;                       {*Pour Conversion en Strings*}
  1665.     Fil1    :Text;                         {*Handle Fichier*}
  1666.     P       :Byte;                         {*Nb De Modules Lus*}
  1667.     T       :Array[1..Max_Mod] Of TWrite;  {*Tableau des Structures*}
  1668.     Old_Mod :String;                       {*Pour Save Old Module String*}
  1669.     Old_Qtt :Byte;                         {*Pour Save Old Module Qtt*}
  1670.     Cor1,Cor2,Cor3:TCoReq;                 {*Command RequestG*}
  1671.     Cin1,Cin2,Cin3:String;                 {*String Pour Command RequestG*}
  1672.  
  1673. {**************************** REDRAW MAIN SCREEN ****************************}
  1674.  
  1675. Procedure REDRAW_FRAME;
  1676. Begin
  1677. HideMouse;
  1678. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  1679. ButtonG(W.X1+60,W.Y2-10-HaF,70,False,B0,'_SAVE'); {*Boutons SAVE, CANCEL*}
  1680. ButtonG(W.X1+210,W.Y2-10-HaF,70,False,B4,'_CANCEL');
  1681.  
  1682. Bevel(W.X1+185,W.Y1+26+HaF*2,W.X2-20,W.Y2-22-HaF*1,1,Col11,True,True);
  1683. Bevel(W.X1+20,W.Y1+26+HaF*2,W.X1+175,W.Y2-22-HaF*1,1,Col11,True,True);
  1684.  
  1685. Str(Qtt_Mod,St);
  1686. ButtonG(W.X1+200,W.Y2-48-HaF*4,105,False,B3,'QTT MODULES: '+ST);
  1687. ButtonG(W.X1+200,W.Y2-40-HaF*3,105,False,B1,'_ADD MODULE');
  1688. ButtonG(W.X1+200,W.Y2-32-HaF*2,105,False,B2,'_DELETE MODULE ');
  1689. Cycler_But(W.X1+170,W.Y1+16+HaF,87,P,C0,Modules);  {*Bouton Cycler*}
  1690. Cin1:=T[P].Name;                                   {*Read Datas Values*}
  1691. Cin2:=T[P].FName;
  1692. Cin3:=T[P].FPath;
  1693. DRAW_CO_REQUESTG(W.X1+30,W.Y2-48-HaF*4,79,16,6,1,Cor1,Cin1);
  1694. DRAW_CO_REQUESTG(W.X1+30,W.Y2-40-HaF*3,79,16,6,1,Cor2,Cin2);
  1695. DRAW_CO_REQUESTG(W.X1+30,W.Y2-32-HaF*2,79,16,6,1,Cor3,Cin3);
  1696.  
  1697. SetColor(Col0);
  1698. DispG(W.X1+50,W.Y1+17+HaF*1,Col7,'SELECTED MODULE -->');
  1699. DispG(W.X1+115,W.Y2-47-HaF*4,Col11,'MODULE');
  1700. DispG(W.X1+115,W.Y2-39-HaF*3,Col11,'FILE NAME');
  1701. DispG(W.X1+115,W.Y2-31-HaF*2,Col11,'PATH NAME');
  1702. ShowMouse;
  1703. End;
  1704.  
  1705. {╔═══════════════════════════════════════════════════════════════════════════╗
  1706.  ║                - CHARGEMENT DU FICHIER "DSMODULE.DTA" -                   ║
  1707.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1708.  
  1709. Function LOAD_MODULES_DATAS:Boolean;       {*Charges Les Datas des Modules*}
  1710. Var   St:String;
  1711.       A:Integer;
  1712. Begin
  1713. Assign(Fil1,'DSMODULE.DTA');
  1714. {$I-}
  1715. Reset(Fil1);
  1716. {$I+}
  1717. If IOResult=0 Then                         {*Teste les Erreurs...*}
  1718.    Begin
  1719.    P:=1;                                   {*1er Module*}
  1720.    While Not Eof(Fil1) do
  1721.       Begin
  1722.       Readln(Fil1,St); Readln(Fil1,St);
  1723.       Readln(Fil1,T[P].Name);              {*Init Labels*}
  1724.       Readln(Fil1,T[P].FName);
  1725.       Readln(Fil1,T[P].FPath);
  1726.       For A:=1 to 13 do Readln(Fil1,St);   {*Skip Some Datas Values*}
  1727.       Inc(P);
  1728.       End;
  1729.    LOAD_MODULES_DATAS:=True;               {*Loading Succesfull*}
  1730.    Close(Fil1);
  1731.    End
  1732.    Else LOAD_MODULES_DATAS:=False;         {*Error Loading !*}
  1733. End;
  1734.  
  1735. {************************ SAUVE LA LISTE DES MODULES ************************}
  1736.  
  1737. Procedure SAVE_CNF_MODULES;                {*Save Liste des Modules et Datas*}
  1738. Var A:Integer;
  1739.  
  1740. Begin
  1741. AFF(32);                                   {*Help on Gadgets*}
  1742. Exit_Flg:=True;                            {*On Sort Aprés ça !!!*}
  1743. Assign(Fil1,'DSMODULE.LIS');
  1744. {$I-}
  1745. Rewrite(Fil1);
  1746. {$I+}
  1747. If IOResult=0 Then                         {*Teste les Erreurs...*}
  1748.    Begin
  1749.    Writeln(Fil1,Modules);
  1750.    Close(Fil1);
  1751.    End
  1752.    Else ERROR_08;                          {*Can't Save Module List*}
  1753.  
  1754. If Qtt_Mod<=3 Then Exit;                   {*Teste si il Existe New Modules*}
  1755.  
  1756. Assign(Fil1,'DSMODULE.DTA');
  1757. {$I-}
  1758. Append(Fil1);                              {*Open At The End of File*}
  1759. {$I+}
  1760. If IOResult=0 Then                         {*Teste les Erreurs...*}
  1761.    Begin
  1762.    For A:=4 to Qtt_Mod do
  1763.       Begin
  1764.       Writeln(Fil1,'************************************');
  1765.       Writeln(Fil1,'');
  1766.       Writeln(Fil1,T[A].Name);             {*Save Labels*}
  1767.       Writeln(Fil1,T[A].FName);
  1768.       Writeln(Fil1,T[A].FPath);
  1769.       Writeln(Fil1,'');
  1770.       Writeln(Fil1,0);
  1771.       Writeln(Fil1,0);
  1772.       Writeln(Fil1,'');
  1773.       Writeln(Fil1,'');
  1774.       Writeln(Fil1,'EXTERNAL');            {*For Sure !!!*}
  1775.       Writeln(Fil1,A);
  1776.       Writeln(Fil1,0);
  1777.       Writeln(Fil1,0);
  1778.       Writeln(Fil1,0);
  1779.       Writeln(Fil1,0);
  1780.       Writeln(Fil1,'NO COMMENTS');         {*To be Continued...*}
  1781.       Writeln(Fil1,'');                    {*Skip Blank Line*}
  1782.       End;
  1783.    Close(Fil1);
  1784.    End
  1785.    Else ERROR_03;                          {*Error Saving Modules Datas!*}
  1786. End;
  1787.  
  1788. {************************* UPDATE VALUES DES DATAS **************************}
  1789.  
  1790. Procedure UPDATE_VALUES;
  1791. Begin
  1792. T[P].Name:=Cin1;                           {*Stocke Valeurs*}
  1793. T[P].FName:=Cin2;
  1794. T[P].FPath:=Cin3;
  1795.  
  1796. REDRAW_FRAME;                              {*Réaffiche le Screen*}
  1797. End;
  1798.  
  1799. {***************** UPDATE VALUES DES DATAS ET LABEL DU MODULE ***************}
  1800.  
  1801. Procedure UPDATE_LABELS;
  1802. Var A:Integer;
  1803. Begin
  1804. T[P].Name:=Cin1;                           {*Stocke Valeur New Label*}
  1805. Modules:='';                               {*Clear String Modules*}
  1806. For A:=1 to Qtt_Mod do
  1807.    Begin
  1808.    Modules:=Modules+T[A].Name+'|';
  1809.    End;
  1810. UPDATE_VALUES;
  1811. End;
  1812.  
  1813. {******************************** ADD MODULE ********************************}
  1814.  
  1815. Procedure ADD_MODULE;
  1816. Begin
  1817. AFF(33);                                   {*Help on Gadgets*}
  1818. If Qtt_Mod=Max_Mod Then Begin              {*Max Modules is Reached !*}
  1819.    ERROR_07; Exit;
  1820.    End;
  1821. Inc(Qtt_Mod);
  1822. Modules:=Modules+'|';                      {*1 Label de Plus*}
  1823. REDRAW_FRAME;                              {*Display Again Screen*}
  1824. End;
  1825.  
  1826. {****************************** DELETE MODULE *******************************}
  1827.  
  1828. Procedure DEL_MODULE;
  1829. Var A:Integer;
  1830.  
  1831. Begin
  1832. AFF(34);                                   {*Help on Gadgets*}
  1833. If Qtt_Mod=3 Then Begin                    {*Cannot Delete Internal Modules*}
  1834.    ERROR_06; Exit;
  1835.    End;
  1836. Dec(Qtt_Mod);
  1837. Modules:=Copy(Modules,1,Length(Modules)-1);{*Delete Last Pipe*}
  1838. For A:=Length(Modules) DownTo 1 do         {*Parcours String Modules*}
  1839.    Begin
  1840.    If Copy(Modules,A,1)='|' Then Begin     {*Search Before Actual Module*}
  1841.       Modules:=Copy(Modules,1,A);          {*New String Modules*}
  1842.       If Modules='' Then Modules:='|';     {*1 Module Minimum !*}
  1843.       REDRAW_FRAME;                        {*Display Again Screen*}
  1844.       Exit;
  1845.       End;
  1846.    End;
  1847. If Modules='' Then Modules:='|';           {*1 Module Minimum !*}
  1848. End;
  1849.  
  1850. {************************ RESTORE ALL BEFORE TO QUIT ************************}
  1851.  
  1852. Procedure RESTORE_ALL;
  1853. Begin
  1854. AFF(36);                                   {*Help on Gadgets*}
  1855. Exit_Flg:=True;
  1856. Modules:=Old_Mod;                          {*Restore Modules String*}
  1857. Qtt_Mod:=Old_Qtt;                          {*Restore Qtt Modules*}
  1858. End;
  1859.  
  1860. {***************** NETTOIE TABLEAU DATAS MODULES EN MEMOIRE ******************}
  1861.  
  1862. Procedure CLEAR_TABLEAU_MODULES;           {*Nettoie Tableau en Mémoire*}
  1863. Var A:Integer;
  1864. Begin
  1865. For A:=1 to Max_Mod do
  1866.    Begin
  1867.    T[A].Name:='-';                         {*Clear Main Labels*}
  1868.    T[A].FName:='-';
  1869.    T[A].FPath:='-';
  1870.    End;
  1871. End;
  1872.  
  1873. {*************************** PROCEDURE PRINCIPALE ***************************}
  1874.  
  1875. Begin
  1876. INIT_WINDOW(250,100,590,180+HaF*6,$51D9,'CONFIGURE MODULES LIST',W);
  1877. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0004,W);
  1878. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  1879.  
  1880. CLEAR_TABLEAU_MODULES;                     {*Nettoie Tableau en Mémoire*}
  1881. If LOAD_MODULES_DATAS=False Then           {*Charges Les Datas des Modules*}
  1882.    Begin
  1883.    ERROR_05; Exit;                         {*Module Datas not Found*}
  1884.    End;
  1885.  
  1886. P:=1;                                      {*Premier Module*}
  1887. DRAW_WINDOW(W);
  1888. REDRAW_FRAME;                              {*Affiche Gadgets*}
  1889. Old_Mod:=Modules;                          {*Save Modules String*}
  1890. Old_Qtt:=Qtt_Mod;                          {*Save Number of Modules*}
  1891. Exit_Flg:=False;
  1892.  
  1893. Repeat
  1894. If WINDOW_READY(W) Then                    {*Fenêtre Ok !*}
  1895.    Begin
  1896.    If GetMsg_But(B0,1)=True Then SAVE_CNF_MODULES;{*Save And Exit*}
  1897.    If GetMsg_But(B1,1)=True Then ADD_MODULE;      {*Add Module*}
  1898.    If GetMsg_But(B2,1)=True Then DEL_MODULE;      {*Sub Module*}
  1899.    If GetMsg_But(B4,1)=True Then RESTORE_ALL;     {*Restore All And Exit*}
  1900.    If GetMsg_But(C0,1)=True Then Begin
  1901.       AFF(35); P:=C0.CyclVal; REDRAW_FRAME; End;  {*Cycler*}
  1902.  
  1903.    If CO_REQUESTG(Cor1,Cin1)=True Then UPDATE_LABELS;{*Co_RequestG*}
  1904.    If CO_REQUESTG(Cor2,Cin2)=True Then UPDATE_VALUES;
  1905.    If CO_REQUESTG(Cor3,Cin3)=True Then UPDATE_VALUES;
  1906.    End;
  1907.  
  1908. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  1909. If Even=9 Then REDRAW_FRAME;
  1910. If Even=1 Then Exit_Flg:=True;             {*On Sort...*}
  1911. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  1912. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  1913. Until Exit_Flg=True;
  1914.  
  1915. If W.Destroyed=False Then KILL_WINDOW(W);  {*Destroy Window !*}
  1916. End;
  1917.  
  1918. {╔═══════════════════════════════════════════════════════════════════════════╗
  1919.  ║                        - RESULTATS DE L'ECRITURE -                        ║
  1920.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1921.  ║ IN.....: It (LONGINT) = Nombres d'Itéations Necéssaire à l'Ecriture.      ║
  1922.  ║          NbO (LONGINT) = Nombre d'Octets Réelement Ecrits.                ║
  1923.  ║ OUT....: / Display Results.                                               ║
  1924.  ║ EXPLAIN: Affiche les Resultats et Statistiques des Modules.               ║
  1925.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1926.  
  1927. Procedure DISPLAY_RESULTS_WRITING(Pos,It,NbO:Longint);
  1928. Var W       :Win;                          {*Structure Window*}
  1929.     B0      :ButG;                         {*Boutons Gadgets*}
  1930.     Exit_Flg:Boolean;
  1931.     Even    :Byte;                         {*Evenement Window*}
  1932.  
  1933. Procedure REDRAW_FRAME;
  1934. Var St:String;
  1935. Begin
  1936. HideMouse;
  1937. Bevel(W.X1+10,W.Y1+10+HaF*1,W.X2-10,W.Y2-15-HaF*1,1,Col7,False,True);
  1938. Bevel(W.X1+20,W.Y1+11+HaF*2,W.X2-20,W.Y2-16-HaF*2,1,Col7,False,True);
  1939. ButtonG(((W.X1+W.X2) Div 2)-35,W.Y2-10-HaF,70,False,B0,'_I KNOW !'); {*Bouton*}
  1940. SetColor(Col15);
  1941. DispG(W.X1+66,W.Y1+15+HaF*1,7,' TEST FILE WRITED ');
  1942. SetColor(Col0);
  1943. Str(NbO,St);
  1944. DispG(W.X1+30,W.Y1+22+HaF*2,7,'NUMBER OF BYTES WRITED . '+St);
  1945. Str(It,St);
  1946. DispG(W.X1+30,W.Y1+27+HaF*3,7,'NUMBER OF ITERATIONS .... '+St);
  1947. Str(T[Pos].Time,St);
  1948. DispG(W.X1+30,W.Y1+32+HaF*4,7,'WRITING TIME (1/1000s) .. '+St);
  1949. Str(T[Pos].Rate,St);
  1950. DispG(W.X1+30,W.Y1+37+HaF*5,7,'TRANSFERT RATE (Kb/s) ... '+St);
  1951. Str(T[Pos].BRate,St);
  1952. DispG(W.X1+30,W.Y1+42+HaF*6,7,'BEST RATE (Kb/s) .......... '+St);
  1953. Str(T[Pos].WRate,St);
  1954. DispG(W.X1+30,W.Y1+47+HaF*7,7,'WORSE RATE (Kb/s) ......... '+St);
  1955. ShowMouse;
  1956. End;
  1957.  
  1958. {*************************** PROCEDURE PRINCIPALE ***************************}
  1959.  
  1960. Begin
  1961. INIT_WINDOW(250,100,490,182+HaF*9,$51D9,'WRITING RESULTS',W);
  1962. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0004,W);
  1963. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  1964.  
  1965. DRAW_WINDOW(W);
  1966. REDRAW_FRAME;                              {*Affiche Gadgets*}
  1967. Exit_Flg:=False;
  1968.  
  1969. Repeat
  1970. If (W.FlgM=False) And (W.IDCMP And $1=$1) Then
  1971.    If GetMsg_But(B0,1)=True Then Exit_Flg:=True;{*Exit*}
  1972.  
  1973. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  1974. If Even=9 Then REDRAW_FRAME;               {*Redraw Contents*}
  1975. If Even=1 Then Exit_Flg:=True;             {*On Sort...*}
  1976. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  1977. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  1978. Until Exit_Flg=True;
  1979.  
  1980. If W.Destroyed=False Then KILL_WINDOW(W);  {*Destroy Window !*}
  1981. End;
  1982.  
  1983. {╔═══════════════════════════════════════════════════════════════════════════╗
  1984.  ║                       - CONFIGURATION DES MACROS -                        ║
  1985.  ╠═══════════════════════════════════════════════════════════════════════════╣
  1986.  ║ IN.....: /                                                                ║
  1987.  ║ OUT....: /                                                                ║
  1988.  ║ EXPLAIN: Permet de Parametrer et d'Executer une Macro.                    ║
  1989.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  1990.  
  1991. Procedure MACRO_PREFS(Var Num:Byte; W4:Win; Var Choix:Byte);
  1992. Var W       :Win;
  1993.     B0,B1,B2,B3:ButG;                      {*Boutons Gadgets*}
  1994.     C0      :ButG;                         {*Bouton Cycler*}
  1995.     S0,S1,S2:Slide;                        {*Sliders Type*}
  1996.     Exit_Flg:Boolean;
  1997.     Even    :Byte;                         {*Evenement Window*}
  1998.     Fil1    :Text;                         {*Handle Fichier*}
  1999.     PCycl   :Byte;                         {*Label Actuel du Bouton Cycler*}
  2000.     DirSel,FilSel:String;                  {*Variables pour File-Requester*}
  2001.     FSize   :Longint;
  2002.     OldPs0,OldPs2:Word;                    {*Old Value -> Restoring*}
  2003.  
  2004. {********************* AFFICHAGE DES VALEURS DES SLIDERS ********************}
  2005.  
  2006. Procedure DISPLAY_VALUE_SLIDERS;
  2007. Var St:String;
  2008.     A:Longint;                             {*Pour Transfert Temporaire*}
  2009. Begin
  2010. SetFillStyle(1,Col7);
  2011. SetColor(0);
  2012. HideMouse;
  2013. A:=S0.Psl*S0.Psl; If A>999 Then Begin A:=A Div 1024; Str(A,St); St:=St+' Kb'; End
  2014.                            Else Str(A,St);
  2015. Bar(W.X1+287,W.Y1+HaF*1+16,W.X1+319,W.Y1+HaF*2+17); DispG(W.X1+287,W.Y1+HaF*1+16,Col7,St);
  2016.  
  2017. A:=S2.Psl*S2.Psl; If A=529 Then A:=512;    {*Correction*}
  2018. If A>999 Then Begin A:=A Div 1024; Str(A,St); St:=St+' Kb'; End
  2019.          Else Str(A,St);
  2020. Bar(W.X1+287,W.Y1+HaF*2+26,W.X1+319,W.Y1+HaF*3+27); DispG(W.X1+287,W.Y1+HaF*2+26,Col7,St);
  2021. Str(S1.Psl,St);DispG(W.X1+287,W.Y1+HaF*3+36,Col7,St+' ');
  2022. ShowMouse;
  2023. End;
  2024.  
  2025. {**************************** REDRAW MAIN SCREEN ****************************}
  2026.  
  2027. Procedure REDRAW_FRAME;
  2028. Begin
  2029. HideMouse;
  2030. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  2031. ButtonG(W.X1+60,W.Y2-10-HaF,70,False,B0,'_EXECUTE'); {*Boutons Gadgets*}
  2032. ButtonG(W.X1+200,W.Y2-10-HaF,70,False,B1,'_CANCEL');
  2033. ButtonG(W.X1+35,W.Y1+HaF*5+55,110,False,B2,'_LOAD POINTS');
  2034. ButtonG(W.X1+185,W.Y1+HaF*5+55,110,False,B3,'_SAVE POINTS');
  2035. Cycler_But(W.X1+97,W.Y1+45+HaF*4,180,PCycl,C0,
  2036.           'TRANSFERT RATE = F(BUFFER)|TRANSFERT RATE = F(FILE SIZE)|');{*Bouton Cycler*}
  2037. Slider(W.X1+127,W.Y1+HaF*1+15,W.X1+240,0,200,20,0,True,S0,S0.Psl);
  2038. Slider(W.X1+127,W.Y1+HaF*2+25,W.X1+240,0,80,8,0,True,S2,S2.Psl);
  2039. Slider(W.X1+127,W.Y1+HaF*3+35,W.X1+240,0,112,11,0,True,S1,S1.Psl);
  2040. SetColor(Col0);
  2041. DispG(W.X1+20,W.Y1+HaF*1+16,Col7,'BUFFER SCAN RANGE');
  2042. DispG(W.X1+62,W.Y1+HaF*2+26,Col7,'STEP RANGE');
  2043. DispG(W.X1+64,W.Y1+HaF*3+36,Col7,'ITERATIONS');
  2044. DispG(W.X1+20,W.Y1+HaF*4+46,Col7,'COURBE TYPE');
  2045. DISPLAY_VALUE_SLIDERS;
  2046. ShowMouse;
  2047. End;
  2048.  
  2049. {*************************** PROCEDURE PRINCIPALE ***************************}
  2050.  
  2051. Begin
  2052. INIT_WINDOW(100,100,430,180+HaF*7,$51D9,'MACRO BOARD AND PREFERENCES',W);
  2053. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0000,W);
  2054. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  2055.  
  2056. PCycl:=1;                                  {*1er Label du Cycler*}
  2057. S0.Psl:=Scan1; S1.Psl:=Ite1; S2.Psl:=Step1;{*Init Valeurs Sliders*}
  2058. DRAW_WINDOW(W);
  2059. REDRAW_FRAME;                              {*Affiche Gadgets*}
  2060. Exit_Flg:=False;
  2061.  
  2062. Repeat
  2063. If WINDOW_READY(W) Then                    {*Fenêtre Ok !*}
  2064.    Begin
  2065.    If GetMsg_But(B0,1)=True Then           {*Maximum Points Reached !*}
  2066.       If (S0.Psl*S0.Psl) Div (S2.Psl*S2.Psl)>Max_Pts Then ERROR_15
  2067.       Else Begin                           {*Got to draw & Exit*}
  2068.       AFF(2);                              {*Display Help on Gadgets*}
  2069.       Choix:=1; Exit_Flg:=True;
  2070.       XMin:=1; XMax:=Qtt_Points; Nb_Points:=Qtt_Points;
  2071.       Scan:=S0.Psl*S0.Psl; Ite:=S1.Psl; Step:=S2.Psl*S2.Psl;
  2072.       If Step=529 Then Step:=512;          {*Correction pour 1/2 Kb*}
  2073.       End;
  2074.    If GetMsg_But(B1,1)=True Then Begin     {*Cancel*}
  2075.       AFF(3);                              {*Display Help on Gadgets*}
  2076.       Choix:=2; Exit_Flg:=True; End;
  2077.    If GetMsg_But(B2,1)=True Then           {*Load Points*}
  2078.       Begin
  2079.       AFF(4);                              {*Display Help on Gadgets*}
  2080.       GET_FILEDIR(200,140,349,'SELECT A DATA POINTS FILE...','_LOAD','*.PTS',0,DirSel,FilSel,FSize);
  2081.       If FilSel<>'' Then Begin
  2082.          LOAD_POINTS(Num,DirSel+FilSel);   {*Test if Cancel*}
  2083.          If Max_Buffer<>0 Then  Begin      {*Pas d'Erreur de Fichier*}
  2084.             Choix:=3; Exit_Flg:=True; End;
  2085.          End;
  2086.       End;
  2087.    If GetMsg_But(B3,1)=True Then           {*Save Points*}
  2088.       Begin
  2089.       AFF(5);                              {*Display Help on Gadgets*}
  2090.       GET_FILEDIR(100,50,300,'PLEASE GIVE A NAME...','_SAVE','*.PTS',0,DirSel,FilSel,FSize);
  2091.       If FilSel<>'' Then SAVE_POINTS(NUM,DirSel+FilSel);
  2092.       End;
  2093.    OldPs0:=S0.Psl; OldPs2:=S2.Psl;         {*Keep Last Value -> Restoring*}
  2094.    If GetMsg_But(C0,1)=True Then PCycl:=C0.CyclVal;  {*Cycler*}
  2095.    If GetMsg_Slider(S0,1)=True Then DISPLAY_VALUE_SLIDERS;
  2096.    If GetMsg_Slider(S1,1)=True Then DISPLAY_VALUE_SLIDERS;
  2097.    If GetMsg_Slider(S2,1)=True Then DISPLAY_VALUE_SLIDERS;
  2098.    End;
  2099.  
  2100. If S0.Psl*S0.Psl < S2.Psl*S2.Psl Then
  2101.    Begin ERROR_16;
  2102.    Slider(W.X1+127,W.Y1+HaF*1+15,W.X1+240,0,200,20,0,True,S0,OldPs0);
  2103.    Slider(W.X1+127,W.Y1+HaF*2+25,W.X1+240,0,80,8,0,True,S2,OldPs2);
  2104.    DISPLAY_VALUE_SLIDERS; End;
  2105.  
  2106. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  2107. If Even=9 Then REDRAW_FRAME;               {*Redraw Contents*}
  2108. If Even=1 Then Begin Exit_Flg:=True; Choix:=2; End;{*On Sort...*}
  2109. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  2110. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  2111. Until Exit_Flg=True;
  2112.  
  2113. KILL_WINDOW(W);                            {*Destroy Window !*}
  2114.  
  2115. Scan1:=S0.Psl; Ite1:=S1.Psl; Step1:=S2.Psl;{*Save Valeurs Sliders*}
  2116.  
  2117. If Choix=3 Then                            {*Display Loaded Courbe*}
  2118.    Begin
  2119.    XMin:=1; XMax:=Qtt_Points; Nb_Points:=Qtt_Points;
  2120.    If Disp_Rate=True
  2121.       Then RENAME_WINDOW('DRAWING TRANSFERT RATE FOR MODULE '+T[Num].Name,W4)
  2122.       Else RENAME_WINDOW('DRAWING SPEED WRITING FOR MODULE '+T[Num].Name,W4);
  2123.    If Disp_Rate=False Then UPDATE_ORDONEE(Num,W4){*Affiche Tj le Taux*}
  2124.       Else Begin
  2125.       If NoClear=False Then CLEAR_WINDOW(W4);    {*Cls Window*}
  2126.       DRAW_REPERE(Num,W4);                 {*Affiche le Repère*}
  2127.       If Grid=True Then DRAW_GRID(W4);     {*Affiche la Grille*}
  2128.       DRAW_COURBE(Num,W4);                 {*Affiche la Courbe*}
  2129.       End;
  2130.    End;
  2131. If (C0.CyclVal=2) And (Choix<>3) And (Choix<>2){*Function not Implemented*}
  2132.    Then Begin ERROR_20; Choix:=2; End;
  2133. End;
  2134.  
  2135. {╔═══════════════════════════════════════════════════════════════════════════╗
  2136.  ║                         - PROCEDURE BARS_GRAPH -                          ║
  2137.  ╠═══════════════════════════════════════════════════════════════════════════╣
  2138.  ║ IN.....: /                                                                ║
  2139.  ║ OUT....: /                                                                ║
  2140.  ║ EXPLAIN: Affiche les Résultats sous forme de graphes.                     ║
  2141.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  2142.  
  2143. Procedure BAR_GRAPH;
  2144. Var W       :Win;
  2145.     B0      :ButG;                         {*Boutons Gadgets*}
  2146.     C0,C2   :ButG;                         {*Boutons Cyclers*}
  2147.     Exit_Flg:Boolean;
  2148.     Even    :Byte;                         {*Evènement Window*}
  2149.     PCyc0,PCyc1,PCyc2:Word;
  2150.  
  2151. {**************************** REDRAW MAIN SCREEN ****************************}
  2152.  
  2153. Procedure REDRAW_FRAME;
  2154. Begin
  2155. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  2156. HideMouse;
  2157. ButtonG(((W.X1+W.X2) Div 2)-80,W.Y2-HaF-10,160,False,B0,'_RETURN TO RESULTS MENU'); {*Boutons Gadgets*}
  2158. Cycler_But(W.X1+20,W.Y2-HaF*2-25,100,PCyc0,C0,
  2159.           '   BARS 3D|   BARS 2D|   BORDERS|     DOTS|    LINES|   CALENDOS|'); {*Bouton Cycler*}
  2160. Cycler_But(W.X1+192,W.Y2-HaF*2-25,100,PCyc2,C2,' WRITING TIME|TRANSFERT RATE|  BEST RATE|  WORSE RATE|');
  2161. ShowMouse;
  2162. End;
  2163.  
  2164. {********************* AFFICHE LE GRAPHIQUE EN QUESTION *********************}
  2165.  
  2166. Procedure DRAW_GRAPHIQUE;
  2167. Const Espace=5;                      {*Espace Entre deux Bars*}
  2168.  
  2169. Var A:Integer;
  2170.     XMin,XMax:Word;                     {*Bornes Gauches et Droites des Gfx*}
  2171.     Step:Word;                          {*Pas = Taille d'une Barre (Exemple)*}
  2172.     Top:Longint;                        {*Hauteur de la Barre en Pixels*}
  2173.     Tet0,Tet1:Longint;                  {*Angles pour PieSlice*}
  2174.     Color:Byte;                         {*Couleurs Pour PieSlice*}
  2175.     MaxPara:Word;                       {*Paramètre Maximum en pixels*}
  2176.     Pourcentage:Real;                   {*Paramètre Maximum en Pourcent*}
  2177.     Haut,Bas:Word;                      {*Max Haut et Base des Graphs*}
  2178.     Somme:Longint;                      {*Somme des Valeurs pour 1 Paramètre*}
  2179.     PrevBas:Integer;                    {*Previous Point for Tracé lines*}
  2180.     St:String;                          {*For Conversion ASCII*}
  2181.  
  2182. {******************* AFFICHE LES POURCENTAGES SUR LE GFX ********************}
  2183.  
  2184. Procedure DISPLAY_PERCENTAGES;      {*Affiche les Pourcentages*}
  2185. Begin
  2186. Str(Round(Pourcentage),St);
  2187. St:=St+' %';
  2188. If PCyc0<5 Then
  2189.    If Top+18>Bas
  2190.    Then DispG(XMin+(Step Div 2)-(TextWidth(St) Div 2)+10, Top-25,Col7,St)
  2191.    Else DispG(XMin+(Step Div 2)-(TextWidth(St) Div 2), Top+4,Col7,St);
  2192. If PCyc0=5 Then
  2193.    DispG(XMin+(Step Div 2)-(TextWidth(St) Div 2)+2, Bas-12,Col7,St);
  2194. End;
  2195.  
  2196. {*************************** PROCEDURE PRINCIPALE ***************************}
  2197.  
  2198. Begin
  2199. XMin:=W.X1+30; XMax:=W.X2-30;           {*Bornes Gauches et Droites des Gfx*}
  2200. Haut:=W.Y1+40; Bas:=W.Y2-HaF*3-34;
  2201. Step:=((XMax-XMin) Div Qtt_Mod)-Espace; {*Calcul du Pas*}
  2202. Case PCyc2 of
  2203.    1: MaxPara:=T[PCyc1].Time;           {*Stocke 1ere Valeur*}
  2204.    2: MaxPara:=T[PCyc1].Rate;
  2205.    3: MaxPara:=T[PCyc1].BRate;
  2206.    4: MaxPara:=T[PCyc1].WRate;
  2207.    End;
  2208. Somme:=0;
  2209. For A:=1 to Qtt_Mod do                  {*Cherche le Maximum du Paramètre*}
  2210. Case PCyc2 of
  2211.    1: If T[A].Time>MaxPara Then MaxPara:=T[A].Time;
  2212.    2: If T[A].Rate>MaxPara Then MaxPara:=T[A].Rate;
  2213.    3: If T[A].BRate>MaxPara Then MaxPara:=T[A].BRate;
  2214.    4: If T[A].WRate>MaxPara Then MaxPara:=T[A].WRate;
  2215.    End;                                 {*On a Récupéré la Valeur la plus Haute*}
  2216.  
  2217. For A:=1 to Qtt_Mod do                  {*Calc la Somme de toutes les Valeurs pour un Paramètre Donné*}
  2218. Case PCyc2 of
  2219.    1: Somme:=Somme+T[A].Time;
  2220.    2: Somme:=Somme+T[A].Rate;
  2221.    3: Somme:=Somme+T[A].BRate;
  2222.    4: Somme:=Somme+T[A].WRate;
  2223.    End;                                 {*On a Récupéré la Valeur la plus Haute*}
  2224.  
  2225. SetFillStyle(1,Col7);
  2226. HideMouse;
  2227. Bar(W.X1+11,W.Y1+11+HaF,W.X2-11,W.Y2-HaF*3-21);
  2228. Tet0:=0;                                {*Initialise Angle Téta à 0*}
  2229. PrevBas:=Bas;                           {*Pour Tracé par Lignes*}
  2230. For A:=1 to Qtt_Mod do
  2231.    Begin
  2232.    Str(A,St); St:='MOD '+St;
  2233.    If PCyc0<>6 Then                     {*Display Number Module*}
  2234.       DispG(XMin+(Step Div 2)-(TextWidth(St) Div 2)+3, Bas+4,Col7,St);
  2235.    SetFillStyle(1,13);
  2236.    Case PCyc2 of                        {*Calcul du Haut des Barres (en %)*}
  2237.       1:Pourcentage:=(100*T[A].Time) / MaxPara;
  2238.       2:Pourcentage:=(100*T[A].Rate) / MaxPara;
  2239.       3:Pourcentage:=(100*T[A].BRate) / MaxPara;
  2240.       4:Pourcentage:=(100*T[A].WRate) / MaxPara;
  2241.       End;
  2242.    Top:=Round(Haut+(Bas-Haut)-((Bas-Haut)*Pourcentage)/100);{*Calcul du Haut des Barres (Pixels)*}
  2243.  
  2244.    Case PCyc0 of
  2245.       1: Bar3D(XMin,Top,XMin+Step,Bas,(Step+1) Div 4,TopOn);{*Bars 3D*}
  2246.       2: Bar(XMin,Top,XMin+Step,Bas);      {*Bars 2D*}
  2247.       3: Rectangle(XMin,Top,XMin+Step,Bas);{*Rectangle*}
  2248.       4: Begin SetFillStyle(9,13);
  2249.             Bar (XMin,Top,XMin+Step,Bas);  {*Dots*}
  2250.             Rectangle(XMin,Top,XMin+Step,Bas);
  2251.             SetFillStyle(1,13);
  2252.             End;
  2253.       5: Begin                             {*Lines*}
  2254.          If A=1 Then Line(XMin,PrevBas,XMin+(Step+Espace) Div 2,Top);
  2255.          If A=Qtt_Mod Then Line(XMin+(Step+Espace) Div 2,Top,XMax-2,Bas);
  2256.          If A<>1 Then Line(XMin-(Step+Espace) Div 2,PrevBas,XMin+(Step+Espace) Div 2,Top);
  2257.          Line(XMin+(Step+Espace) Div 2,Bas,XMin+(Step+Espace) Div 2,Top);
  2258.          Line(XMin,Bas,XMax-Espace+2,Bas);
  2259.          PrevBas:=Top;
  2260.          End;
  2261.       6: Begin                             {*PieSlice = Calendos*}
  2262.             Color:=12+A;
  2263.             If Color=16 Then Color:=Color+1;
  2264.             SetFillStyle(1,Color);
  2265.             Case PCyc2 of                  {*Récupère Valeur en Fn du Paramètre*}
  2266.                1:Pourcentage:=(100*T[A].Time) / Somme;
  2267.                2:Pourcentage:=(100*T[A].Rate) / Somme;
  2268.                3:Pourcentage:=(100*T[A].BRate) / Somme;
  2269.                4:Pourcentage:=(100*T[A].WRate) / Somme;
  2270.                End;
  2271.             Tet1:=Round(Tet0+(360*Pourcentage)/100);{*Calcule Nouvel Angle*}
  2272.             If Tet1>360 Then Tet1:=360;
  2273.             If Tet0>=360 Then Begin ShowMouse; Exit; End; {*Pas de Draw*}
  2274.             If (A=Qtt_Mod) And (Tet1<360) Then Tet1:=360;
  2275.             SetColor(Col0);
  2276.             PieSlice(W.X1+96,W.Y1+86,Tet0,Tet1,72);
  2277.             Tet0:=Tet1;
  2278.             Bevel(W.X1+185, W.Y1+15+A*5+(HaF+3)*A, W.X1+220, W.Y1+10+(A+1)*5+(HaF+3)*(A+1),1,Color,False,True);
  2279.             SetColor(Col0);
  2280.             DispG(W.X1+230, W.Y1+16+A*5+(HaF+3)*A, 7,T[A].Name);
  2281.  
  2282.             Str(Round(Pourcentage),St); St:=St+' %';
  2283.             DispG(W.X1+190, W.Y1+16+A*5+(HaF+3)*A, Color,St);
  2284.             SetFillStyle(1,13);
  2285.          End;
  2286.       End;
  2287.    DISPLAY_PERCENTAGES;                      {*Affiche les Pourcentages*}
  2288.    XMin:=XMin+Step+Espace;                           {*Incrément du Pas*}
  2289.    End;
  2290. ShowMouse;
  2291. End;
  2292.  
  2293. {*************************** PROCEDURE PRINCIPALE ***************************}
  2294.  
  2295. Begin
  2296. AFF(9);                                    {*Display Help on Gadgets*}
  2297. INIT_WINDOW(170,120,500,140+150+HaF*3,$51D9,'GRAPHICAL REPRESENTATION',W);
  2298. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0000,W);
  2299. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  2300.  
  2301. DRAW_WINDOW(W);
  2302. PCyc0:=1;                                  {*Init Valeurs Cyclers*}
  2303. PCyc1:=1;
  2304. PCyc2:=2;
  2305. REDRAW_FRAME;                              {*Affiche Gadgets*}
  2306. DRAW_GRAPHIQUE;                            {*Affiche le Graphique Concerné*}
  2307. Exit_Flg:=False;
  2308.  
  2309. Repeat
  2310. If WINDOW_READY(W) Then                    {*Fenêtre Ok !*}
  2311.    Begin
  2312.    If GetMsg_But(B0,1)=True Then Exit_Flg:=True;{*Exit*}
  2313.    If GetMsg_But(C0,1)=True Then Begin     {*Cycler Forme de Représentations*}
  2314.                             PCyc0:=C0.CyclVal; AFF(6);
  2315.                             DRAW_GRAPHIQUE; End;
  2316.    If GetMsg_But(C2,1)=True Then Begin     {*Cycler Variable*}
  2317.                             PCyc2:=C2.CyclVal; AFF(7);
  2318.                             DRAW_GRAPHIQUE; End;
  2319.    End;
  2320.  
  2321. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  2322. If Even=9 Then Begin REDRAW_FRAME;         {*Redraw Contents*}
  2323.                DRAW_GRAPHIQUE; End;
  2324. If Even=1 Then Exit_Flg:=True;             {*On Sort...*}
  2325. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  2326. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  2327. Until Exit_Flg=True;
  2328.  
  2329. KILL_WINDOW(W);                            {*Destroy Window !*}
  2330. End;
  2331.  
  2332. {╔═══════════════════════════════════════════════════════════════════════════╗
  2333.  ║                         - PROCEDURE STATISTICS -                          ║
  2334.  ╠═══════════════════════════════════════════════════════════════════════════╣
  2335.  ║ IN.....: /                                                                ║
  2336.  ║ OUT....: /                                                                ║
  2337.  ║ EXPLAIN: Affiche les Résultats sous forme de Chiffres.                    ║
  2338.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  2339.  
  2340. Procedure STATISTICS;
  2341. Var W       :Win;
  2342.     B0      :ButG;                         {*Boutons Gadgets*}
  2343.     S0      :Slide;                        {*Slider*}
  2344.     Exit_Flg:Boolean;
  2345.     Even    :Byte;                         {*Evènement Window*}
  2346.     PCyc0,PCyc1,PCyc2:Word;
  2347.  
  2348. {**************************** REDRAW MAIN SCREEN ****************************}
  2349.  
  2350. Procedure REDRAW_FRAME;
  2351. Var A:Byte;
  2352.     St:String;
  2353.     MTime,MRate,MBRate,MWRate:Longint;     {*Stockage des Moyennes*}
  2354.     TV:Longint;                            {*Variable pour Calcul*}
  2355.  
  2356. Begin
  2357. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  2358. HideMouse;
  2359. ButtonG(((W.X1+W.X2) Div 2)-80,W.Y2-HaF-10,160,False,B0,'_RETURN TO RESULTS MENU'); {*Boutons Gadgets*}
  2360. Slider(W.X2-38,W.Y1+HaF*1+15,0,W.Y2-HaF*1-52,100,15,1,True,S0,S0.Psl);
  2361.  
  2362. MTime:=0; MRate:=0; MBRate:=0; MWRate:=0;
  2363. For A:=1 to 4 do                           {*Affiche Box et Tableau Design*}
  2364.    Begin
  2365.    Bevel(W.X1+35+A*95,W.Y1+15+HaF*1,W.X1+120+A*95,W.Y1+30+HaF*1,1,Col11,False,True);
  2366.    Bevel(W.X1+35+A*95,W.Y1+30+HaF*1,W.X1+78+A*95,W.Y1+45+HaF*1,1,Col5,False,True);
  2367.    Bevel(W.X1+79+A*95,W.Y1+30+HaF*1,W.X1+120+A*95,W.Y1+45+HaF*1,1,Col5,False,True);
  2368.    SetColor(Col0); DispG(W.X1+88+A*95,W.Y1+32+HaF*1,Col5,'PERC');
  2369.    SetColor(Col0); DispG(W.X1+40+A*95,W.Y1+32+HaF*1,Col5,'Kb/Sec');
  2370.    MTime:=MTime+T[A].Time;
  2371.    MRate:=MRate+T[A].Rate;
  2372.    MBRate:=MBRate+T[A].BRate;
  2373.    MWRate:=MWRate+T[A].WRate;
  2374.    End;
  2375.  
  2376. MTime:=MTime Div Qtt_Mod;                  {*Calcul des Moyennes*}
  2377. MRate:=MRate Div Qtt_Mod;
  2378. MBRate:=MBRate Div Qtt_Mod;
  2379. MWRate:=MWRate Div Qtt_Mod;
  2380. For A:=1 to 4 do                           {*Affiche Box et Tableau Design*}
  2381.    Begin
  2382.    Case A of                               {*Affiche Moyennes*}
  2383.       1: Str(MTime,St);
  2384.       2: Str(MRate,St);
  2385.       3: Str(MBRate,St);
  2386.       4: Str(MWRate,St);
  2387.       End;
  2388.    Bevel(W.X1+35+A*95,W.Y1+70+HaF*6,W.X1+120+A*95,W.Y1+85+HaF*6,1,Col11,False,True);
  2389.    SetColor(Col0); St:='MOY = '+St;
  2390.    DispG(W.X1+77+A*95-TextWidth(St) Div 2,W.Y1+72+HaF*6,Col11,St);
  2391.    End;
  2392.  
  2393. SetColor(Col0); DispG(W.X1+39+95,W.Y1+32+HaF*1,Col5,'1/1000');
  2394. DispG(W.X1+49+95,W.Y1+17+HaF,Col11,'WRITE TIME');
  2395. DispG(W.X1+162+95,W.Y1+17+HaF,Col11,'RATE');
  2396. DispG(W.X1+242+95,W.Y1+17+HaF,Col11,'BEST RATE');
  2397. DispG(W.X1+333+95,W.Y1+17+HaF,Col11,'WORSE RATE');
  2398. For A:=1 to Qtt_Mod do
  2399.    Begin
  2400.    Bevel(W.X1+20,W.Y1+40+A*8+HaF*A,W.X1+115,W.Y1+55+A*8+HaF*A,1,Col12,False,True);
  2401.    SetColor(Col0); DispG(W.X1+33,W.Y1+42+A*8+HaF*A,Col12,T[A].Name);
  2402.    Bevel(W.X1+35+95,W.Y1+40+A*8+HaF*A,W.X1+78+95,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2403.    Str(T[A].Time,St); SetColor(Col0); DispG(W.X1+57-TextWidth(St) Div 2+95,W.Y1+42+A*8+HaF*A,Col7,St);
  2404.    Bevel(W.X1+35+95*2,W.Y1+40+A*8+HaF*A,W.X1+78+95*2,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2405.    Str(T[A].Rate,St); SetColor(Col0); DispG(W.X1+57-TextWidth(St) Div 2+95*2,W.Y1+42+A*8+HaF*A,Col7,St);
  2406.    Bevel(W.X1+35+95*3,W.Y1+40+A*8+HaF*A,W.X1+78+95*3,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2407.    Str(T[A].BRate,St); SetColor(Col0); DispG(W.X1+57-TextWidth(St) Div 2+95*3,W.Y1+42+A*8+HaF*A,Col7,St);
  2408.    Bevel(W.X1+35+95*4,W.Y1+40+A*8+HaF*A,W.X1+78+95*4,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2409.    Str(T[A].WRate,St); SetColor(Col0); DispG(W.X1+57-TextWidth(St) Div 2+95*4,W.Y1+42+A*8+HaF*A,Col7,St);
  2410.  
  2411.    Bevel(W.X1+79+95,W.Y1+40+A*8+HaF*A,W.X1+120+95,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2412.    TV:=(T[A].Time*100) Div MTime; If TV<100 Then Begin Str(100-TV,St); St:='-'+St; End
  2413.                                             Else Begin Str(TV-100,St); St:='+'+St; End;
  2414.    SetColor(Col0); DispG(W.X1+100-TextWidth(St) Div 2+95,W.Y1+42+A*8+HaF*A,Col7,St);
  2415.  
  2416.    Bevel(W.X1+79+95*2,W.Y1+40+A*8+HaF*A,W.X1+120+95*2,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2417.    TV:=(T[A].Rate*100) Div MRate; If TV<100 Then Begin Str(100-TV,St); St:='-'+St; End
  2418.                                             Else Begin Str(TV-100,St); St:='+'+St; End;
  2419.    SetColor(Col0); DispG(W.X1+100-TextWidth(St) Div 2+95*2,W.Y1+42+A*8+HaF*A,Col7,St);
  2420.  
  2421.    Bevel(W.X1+79+95*3,W.Y1+40+A*8+HaF*A,W.X1+120+95*3,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2422.    TV:=(T[A].BRate*100) Div MBRate; If TV<100 Then Begin Str(100-TV,St); St:='-'+St; End
  2423.                                             Else Begin Str(TV-100,St); St:='+'+St; End;
  2424.    SetColor(Col0); DispG(W.X1+100-TextWidth(St) Div 2+95*3,W.Y1+42+A*8+HaF*A,Col7,St);
  2425.  
  2426.    Bevel(W.X1+79+95*4,W.Y1+40+A*8+HaF*A,W.X1+120+95*4,W.Y1+55+A*8+HaF*A,1,Col7,False,True);
  2427.    TV:=(T[A].WRate*100) Div MWRate; If TV<100 Then Begin Str(100-TV,St); St:='-'+St; End
  2428.                                             Else Begin Str(TV-100,St); St:='+'+St; End;
  2429.    SetColor(Col0); DispG(W.X1+100-TextWidth(St) Div 2+95*4,W.Y1+42+A*8+HaF*A,Col7,St);
  2430.    End;
  2431. ShowMouse;
  2432. End;
  2433.  
  2434. {*************************** PROCEDURE PRINCIPALE ***************************}
  2435.  
  2436. Begin
  2437. AFF(8);                                    {*Display Help on Gadgets*}
  2438. INIT_WINDOW(50,120,600,140+65+HaF*(5+Qtt_Mod),$51D9,'STATISTICAL REPRESENTATION',W);
  2439. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0000,W);
  2440. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  2441.  
  2442. DRAW_WINDOW(W);
  2443. S0.Psl:=1;                                 {*Init Valeurs Slider*}
  2444. REDRAW_FRAME;                              {*Affiche Gadgets*}
  2445. Exit_Flg:=False;
  2446.  
  2447. Repeat
  2448. If WINDOW_READY(W) Then                    {*Fenêtre Ok !*}
  2449.    Begin
  2450.    If GetMsg_But(B0,1)=True Then Exit_Flg:=True;{*Exit*}
  2451.    If GetMsg_Slider(S0,1)=True Then AFF(38);{*Aff Help*}
  2452.    End;
  2453.  
  2454. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  2455. If Even=9 Then REDRAW_FRAME;               {*Redraw Contents*}
  2456. If Even=1 Then Exit_Flg:=True;             {*On Sort...*}
  2457. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  2458. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  2459. Until Exit_Flg=True;
  2460.  
  2461. KILL_WINDOW(W);                            {*Destroy Window !*}
  2462. End;
  2463.  
  2464. {╔═══════════════════════════════════════════════════════════════════════════╗
  2465.  ║                        - PROCEDURE MAIN_RESULTS -                         ║
  2466.  ╠═══════════════════════════════════════════════════════════════════════════╣
  2467.  ║ IN.....: /                                                                ║
  2468.  ║ OUT....: /                                                                ║
  2469.  ║ EXPLAIN: Affiche et Gère le Menu principal pour les Results.              ║
  2470.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  2471.  
  2472. Procedure MAIN_RESULTS;                 {*Résultats Généraux*}
  2473. Var W       :Win;
  2474.     B0,B1,B2:ButG;                         {*Boutons Gadgets*}
  2475.     Exit_Flg:Boolean;
  2476.     Even    :Byte;                         {*Evenement Window*}
  2477.  
  2478. {**************************** REDRAW MAIN SCREEN ****************************}
  2479.  
  2480. Procedure REDRAW_FRAME;
  2481. Begin
  2482. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  2483. HideMouse;
  2484. ButtonG(W.X1+20,W.Y1+HaF+15,80,False,B0,'_BARS GRAPH'); {*Boutons Gadgets*}
  2485. ButtonG(W.X1+110,W.Y1+HaF+15,80,False,B1,'_STATISTICS');
  2486. ButtonG(W.X1+30,W.Y2-HaF-10,150,False,B2,'_RETURN TO MAIN MENU');
  2487. ShowMouse;
  2488. End;
  2489.  
  2490. {*************************** PROCEDURE PRINCIPALE ***************************}
  2491.  
  2492. Begin
  2493. AFF(10);                                   {*Display Help on Gadgets*}
  2494. If Modules='|'Then Begin ERROR_01; Exit; End;        {*List is Empty*}
  2495.  
  2496. INIT_WINDOW(100,90,310,130+HaF*3,$51D9,'SELECT TYPE OF RESULTS...',W);
  2497. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0000,W);
  2498. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  2499.  
  2500. DRAW_WINDOW(W);
  2501. REDRAW_FRAME;                              {*Affiche Gadgets*}
  2502. Exit_Flg:=False;
  2503.  
  2504. Repeat
  2505. If WINDOW_READY(W) Then                    {*Fenêtre Ok !*}
  2506.    Begin
  2507.    If GetMsg_But(B0,1)=True Then BAR_GRAPH; {*Résultats sous Formes de Graphes*}
  2508.    If GetMsg_But(B1,1)=True Then STATISTICS;{*Résultats sous Formes de Chiffres*}
  2509.    If GetMsg_But(B2,1)=True Then Exit_Flg:=True;{*Exit*}
  2510.    End;
  2511.  
  2512. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  2513. If Even=9 Then REDRAW_FRAME;               {*Redraw Contents*}
  2514. If Even=1 Then Exit_Flg:=True;             {*On Sort...*}
  2515. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  2516. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  2517. Until Exit_Flg=True;
  2518.  
  2519. KILL_WINDOW(W);                            {*Destroy Window !*}
  2520. End;
  2521.  
  2522. {╔═══════════════════════════════════════════════════════════════════════════╗
  2523.  ║                        - FUNCTION SELECT_DRIVE -                          ║
  2524.  ╠═══════════════════════════════════════════════════════════════════════════╣
  2525.  ║ IN.....: /                                                                ║
  2526.  ║ OUT....: Num (BYTE) :                                                     ║
  2527.  ║ EXPLAIN: Demande la Selection d'une unité de Disque.                      ║
  2528.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  2529.  
  2530. Function SELECT_DRIVE:Shortint;         {*Sélectionne Drive to Write Sectors*}
  2531. Var W       :Win;
  2532.     B0      :ButG;                         {*Bouton Gadget*}
  2533.     C0      :ButG;                         {*Bouton Cycler*}
  2534.     Exit_Flg:Boolean;
  2535.     Even    :Byte;                         {*Evenement Window*}
  2536.  
  2537. {**************************** REDRAW MAIN SCREEN ****************************}
  2538.  
  2539. Procedure REDRAW_FRAME;
  2540. Begin
  2541. Bevel(W.X1+10,W.Y1+10+HaF,W.X2-10,W.Y2-15-HaF,1,Col7,False,True);
  2542. ButtonG(((W.X1+W.X2) Div 2)-55,W.Y2-HaF-10,110,False,B0,'_GO TO WRITE'); {*Bouton Gadget*}
  2543. Cycler_But(W.X1+105,W.Y1+HaF*2+25,63,C0.CyclVal,C0,' DISK A:| DISK B:|  HD C:|  HD D:|');
  2544. DispG(W.X1+28,W.Y1+HaF+15,Col7,'PLEASE SELECT DRIVE UNIT TO WRITE TRACKS');
  2545. End;
  2546.  
  2547. {*************************** PROCEDURE PRINCIPALE ***************************}
  2548.  
  2549. Begin
  2550. AFF(39);                                   {*Display Help on Gadgets*}
  2551. INIT_WINDOW(190,90,480,140+HaF*4,$51D9,'SELECT DRIVE...',W);
  2552. SUP_WINDOW(0,0,0,0,0,0,0,0,0,Col5,$0000,W);
  2553. If NError<>0 Then Exit;                    {*Erreurs Initialisations*}
  2554.  
  2555. C0.CyclVal:=4;
  2556. DRAW_WINDOW(W);
  2557. REDRAW_FRAME;                              {*Affiche Gadgets*}
  2558. Exit_Flg:=False;
  2559.  
  2560. Repeat
  2561. If WINDOW_READY(W) Then                    {*Fenêtre Ok !*}
  2562.    Begin
  2563.    If GetMsg_But(B0,1)=True Then Exit_Flg:=True;{*Résultats sous Formes de Graphes*}
  2564.    If GetMsg_But(C0,1)=True Then Else;     {*Cycler Gadget*}
  2565.    End;
  2566.  
  2567. Even:=ACTIVE_WINDOW(W);                    {*Evenements Window*}
  2568. If Even=9 Then REDRAW_FRAME;               {*Redraw Contents*}
  2569. If Even=1 Then Exit_Flg:=True;             {*On Sort...*}
  2570. If Even=5 Then SET_POINTER(P_Arrow);       {*Pointer Arrow*}
  2571. If Even=6 Then SET_POINTER(P_Busy);        {*Pointer Busy*}
  2572. Until Exit_Flg=True;
  2573.  
  2574. KILL_WINDOW(W);                            {*Destroy Window !*}
  2575. SELECT_DRIVE:=C0.CyclVal-1;                {*Renvois Valeur du Drive*}
  2576. If Even=1 Then SELECT_DRIVE:=-1;           {*Annulation*}
  2577. End;
  2578.  
  2579. {╔═══════════════════════════════════════════════════════════════════════════╗
  2580.  ║                           CODE UNITE PRINCIPALE                           ║
  2581.  ╚═══════════════════════════════════════════════════════════════════════════╝}
  2582.  
  2583. Begin
  2584. End.
  2585.