home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 26 / CD_ASCQ_26_1295.iso / vrac / viewer15.zip / HELVB.FON / fnt next >
Text File  |  1993-11-23  |  17KB  |  637 lines
  1.  b, short a1, short b1, char *ti ) {
  2.  
  3.   // Setto i dati e modalita'
  4.   x  = a;  y  = b;
  5.   x1 = a1; y1 = b1;
  6.   sfondo      = sf;
  7.  
  8.   // Verifico il titolo
  9.   if( ti ) strcpy( titolo, ti );
  10.   else     *titolo = '\0';       // Annullo il titolo
  11.  
  12.   Draw();    // Disegno la finestra
  13.  
  14. };
  15.  
  16.  
  17. // Disegno la finestra ed il contenuto
  18. void Wind::Draw() {
  19.  
  20.   size_t len;
  21.  
  22.   // Disegna il primo contorno
  23.   _setcolor( 8 );
  24.   _rectangle( _GBORDER, x, y, x1, y1 );
  25.  
  26.   // Disegno linee di riempimento
  27.   _setcolor( 7 );
  28.   _rectangle( _GBORDER, x + 1, y + 1, x1 - 1, y1 - 1 );
  29.   _rectangle( _GBORDER, x + 2, y + 2, x1 - 2, y1 - 2 );
  30.  
  31.   // Verifico la lunghezza del titolo, nel caso che sia > 0
  32.   // il titolo c'e' occorre disegnare lo spazio per esso
  33.   if( ( len = strlen( titolo ) ) > 0 ) {
  34.  
  35.     short spess = 4 + TXT_HGT + 4;
  36.  
  37.     // Disegno spazio per il titolo della finestra
  38.     _rectangle( _GFILLINTERIOR, x + 1, y + 1, x1 - 1, y + spess );
  39.  
  40.     // Disegno il secondo contorno
  41.     _setcolor( 8 );
  42.     _rectangle( _GBORDER, x + 3, y + spess + 1, x1 - 3, y1 - 3 );
  43.  
  44.     // Disegno l'interno della finestra con il colore di sfondo prescelto
  45.     _setcolor( sfondo );
  46.     _rectangle( _GFILLINTERIOR, x + 4, y + spess + 2, x1 - 4, y1 - 4 );
  47.  
  48.     // Stampo a video anche il titolo
  49.     _moveto( ( x + 3 ) + ( ( ( x1 - 3 ) - ( x + 3 ) ) / 2 ) -
  50.              ( TXT_WDT * len ) / 2, ( y + 1 ) + ( ( ( y + spess ) - ( y + 1 ) ) / 2 ) -
  51.              ( TXT_HGT / 2 ) );
  52.     _setcolor( 0 );
  53.     _outgtext( titolo );
  54.  
  55.   }
  56.   else {
  57.  
  58.     // Disegno il secondo contorno
  59.     _setcolor( 8 );
  60.     _rectangle( _GBORDER, x + 3, y + 3, x1 - 3, y1 - 3 );
  61.  
  62.     // Disegno l'interno della finestra con il colore di sfondo prescelto
  63.     _setcolor( sfondo );
  64.     _rectangle( _GFILLINTERIOR, x + 4, y + 4, x1 - 4, y1 - 4 );
  65.   }
  66.  
  67. };
  68.  
  69.  
  70. // Distruttore della finestra
  71. Wind::~Wind() {
  72.  
  73.   // Ricopro la zona con il colore nero
  74.   _setcolor( col_Viewer );
  75.   _rectangle( _GFILLINTERIOR, x, y, x1, y1 );
  76.  
  77. };
  78.  
  79.  
  80. // Implementazione metodi per la gestione dell'apertura di un file
  81. // tramite Dialog_Box
  82.  
  83. // La funzione crea la finestra e setta il tipo di dati da prelevare
  84. WinOpen::WinOpen( short a, short b, char *ntp, char *title ) {
  85.  
  86.   // Setta il numero di file prelevati
  87.   max_files = win_files = 0;
  88.  
  89.   // Setta il numero di direttori prelevati
  90.   max_drive = win_drive = 0;
  91.  
  92.   // Setto le coordinate d'ingombro delle finestre
  93.   x = a; y = b;
  94.  
  95.   // Setto anche i tipi di files da prelevare
  96.   strcpy( type, ntp );
  97.  
  98.   // Disegno l'ingombro delle finestre
  99.   finestra = new Wind( col_WOpen, x, y - 15, x + 400, y + 200, title );
  100.  
  101.   // Setta tipo di scrittura
  102.   _registerfonts( "oem08.fon" );
  103.   _setfont( "t'oem08'h5w5b" );
  104.  
  105.   // Scrivo il nome del file
  106.   _setcolor( 0 );
  107.   _moveto( x + 10, y + 10 );
  108.   _outgtext( "NAME:" );
  109.   _rectangle( _GBORDER, x + 55, y + 7, x + 400 - 20, y + 19 );
  110.  
  111.   // Finestra con la lista dei files e dei direttori
  112.   _setcolor( 0 );
  113.   _moveto( x + 10, y + 30 );
  114.   _outgtext( "Files" );
  115.   _rectangle( _GBORDER, x + 10, y + 40, x + 218, y + 150 );
  116.  
  117.   // Finestra con la lista dei drive disponibili
  118.   _setcolor( 0 );
  119.   _moveto( x + 240, y + 30 );
  120.   _outgtext( "Drives" );
  121.   _rectangle( _GBORDER, x + 240, y + 40, x + 350, y + 150 );
  122.  
  123.   // Disegno la barra per il caricamento dei files
  124.   _moveto( x + 15, y + 160 );  _outgtext( "0%" );
  125.   _moveto( x + 353, y + 160 ); _outgtext( "100%" );
  126.   _setcolor( 1 );
  127.   _rectangle( _GFILLINTERIOR, x + 31, y + 160, x + 351, y + 170 );
  128.  
  129. };
  130.  
  131. // Distruttore della classe wopen
  132. WinOpen::~WinOpen() {
  133.  
  134.   // Elimino la finestra generata
  135.   delete finestra;
  136. };
  137.  
  138.  
  139. // La funzione legge tutti i files dal direttorio corrente
  140. // e li depone nella lista, che poi viene utilizzata per la selezione
  141. void WinOpen::LoadList() {
  142.  
  143.   struct    find_t c_file;
  144.   unsigned  rtes, j, drives, odrv, ndrv, k;
  145.   char      names[ 128 ];
  146.  
  147.   // Compongo il percorso per la ricerca dei direttori
  148.   strcpy( names, work_dir ); strcat( names, "\\" );
  149.   strcat( names, "*." );
  150.  
  151.   // Dapprima prelevo tutti i nomi dei direttori
  152.   for( _dos_findfirst( names, _A_SUBDIR, &c_file ), j = rtes = 0;
  153.        rtes == 0;
  154.        rtes = _dos_findnext( &c_file ) ) {
  155.  
  156.     // Controllo se il direttorio e' '.' non lo inserisco
  157.     if( strcmp( c_file.name, "." ) ) {
  158.  
  159.       // Solo se il file e' di tipo sottodirettorio lo inserisco
  160.       if( c_file.attrib == _A_SUBDIR ) {
  161.  
  162.         // Memorizzo il nome ed il tipo
  163.         strcpy( lista[ j ].name, c_file.name );
  164.         lista[ j++ ].attrib = _A_SUBDIR;
  165.       }
  166.     }
  167.   }
  168.  
  169.   // Compongo il percorso per la ricerca dei files
  170.   strcpy( names, work_dir ); strcat( names, "\\" );
  171.   strcat( names, type );
  172.  
  173.   // Dapprima prelevo tutti i nomi dei files
  174.   for( _dos_findfirst( names, _A_ARCH, &c_file ), rtes = 0;
  175.        rtes == 0;
  176.        rtes = _dos_findnext( &c_file ) ) {
  177.  
  178.     // Controllo se e' stato prelevato un archivio
  179.     if( c_file.attrib == _A_ARCH ) {
  180.  
  181.       // Memorizzo il nome ed il tipo
  182.       strcpy( lista[ j ].name, c_file.name );
  183.       lista[ j++ ].attrib = _A_NORMAL;
  184.     }
  185.   }
  186.  
  187.   // Setto il numero massimo di files selezionati
  188.   max_files = j;
  189.  
  190.   // Setto il numero massimo di files visibili in finestra
  191.   win_files = ( max_files < 10 ) ? max_files : 10;
  192.  
  193.   // Prelevo il drive di default
  194.   _dos_getdrive( &odrv );
  195.  
  196.   // Stampo anche il numero massimo di drive disponibili
  197.   for( j = k = 0; j < 27; j++ ) {
  198.  
  199.     // Eseguo il settaggio di tutti i drive disponibili
  200.     _dos_setdrive( j, &drives );
  201.  
  202.     // Controllo se e' stato settato
  203.     _dos_getdrive( &ndrv );
  204.  
  205.     // Se il drive e' stato settato lo memorizzo nel vettore dei drives
  206.     if( ndrv == j ) _drives[ k++ ] = 'A' + ndrv - 1;
  207.   }
  208.  
  209.   // Quindi setto il numero massimo di drives disponibili
  210.   max_drive = k;
  211.   win_drive = ( max_drive < 10 ) ? max_drive : 10;
  212.  
  213.   // Ripristino drives originale
  214.   _dos_setdrive( odrv, &drives );
  215.  
  216. };
  217.  
  218. // La funzione data una struttura di tipo file analizza il tipo di
  219. // dato in esso contenuto, file o directory e quindi restituisce
  220. // un buffer con il nome corretto, nel caso sia un direttorio
  221. char *WinOpen::CorrectName( file fl ) {
  222.  
  223.   size_t      j;
  224.   static char pname[ 64 ];
  225.  
  226.   // Copio il nome nel buffer secondario
  227.   strcpy( pname, fl.name );
  228.  
  229.   // Controllo il tipo di dato
  230.   if( fl.attrib == _A_SUBDIR ) {
  231.  
  232.     // Inserisco gli spazi nel nome
  233.     for( j = strlen( pname ); j < 15; j++ ) pname[ j ] = ' ';
  234.     pname[ j ] = '\0';    // Inserisco il null
  235.  
  236.     // Quindi copio la proprieta'
  237.     strcat( pname, "<DIR>" );
  238.   }
  239.  
  240.   // Ritorno la variabile contenente il nome
  241.   return pname;
  242. };
  243.  
  244.  
  245. // La funzione permette di selezionare il file
  246. void WinOpen::SelectFiles() {
  247.  
  248.   short  x1, y1;
  249.   char   fname[ 128 ];
  250.  
  251.   // Il valore di fval e' sempre compreso fra 1 e 10
  252.   x1 = x + 18;
  253.   y1 = y + 48 + 10 * ( fval - 1 );
  254.  
  255.   // Quindi disegno la nuova selezione
  256.   _setcolor( 0 );
  257.   _rectangle( _GFILLINTERIOR, x1 - 2, y1 - 2, x1 + 180, y1 + 8 );
  258.  
  259.   // Disegno anche il testo
  260.   _setcolor( 15 );
  261.   _moveto( x1, y1 );
  262.  
  263.   // Scrivo il file evidenziato
  264.   _outgtext( CorrectName( lista[ firstf + fval - 2 ] ) );
  265.  
  266.   // Pulisco il rettangolo con il nome
  267.   _setcolor( 15 );
  268.   _rectangle( _GFILLINTERIOR, x + 56, y + 8, x + 379, y + 18 );
  269.  
  270.   // Sposto il cursore e setto il colore
  271.   _moveto( x + 60, y + 10 ); _setcolor( 0 );
  272.  
  273.   // Compongo parte del nome
  274.   strcpy( fname, work_dir ); strcat( fname, "\\" );
  275.   strcat( fname, lista[ firstf + fval - 2 ].name );
  276.  
  277.   // Quindi scrivo anche il nome del direttorio se e' tale
  278.   if( lista[ firstf + fval - 2 ].attrib == _A_SUBDIR ) {
  279.  
  280.     // Accodo lo slash che indica che e'' un direttorio
  281.     strcat( fname, "\\" );
  282.   }
  283.  
  284.   // Alla fine stampo il risultato
  285.   _outgtext( fname );
  286.  
  287. };
  288.  
  289. // La funzione permette di selezionare il drive
  290. void WinOpen::SelectDrive() {
  291.  
  292.   short  x1, y1;
  293.   char   driv[ 3 ];
  294.  
  295.   // Il valore di dval e' sempre compreso fra 1 e 10
  296.   x1 = x + 251;
  297.   y1 = y + 48 + 10 * ( dval - 1 );
  298.  
  299.   // Quindi disegno la nuova selezione
  300.   _setcolor( 0 );
  301.   _rectangle( _GFILLINTERIOR, x1 - 2, y1 - 2, x1 + 80, y1 + 8 );
  302.  
  303.   // Disegno anche il testo
  304.   _setcolor( 15 );
  305.   _moveto( x1, y1 );
  306.  
  307.   // Compongo il nome del drive
  308.   driv[ 0 ] = _drives[ firstd + dval - 2 ];
  309.   driv[ 1 ] = ':';
  310.   driv[ 2 ] = '\0';
  311.  
  312.   // Scrivo il file evidenziato
  313.   _outgtext( driv );
  314.  
  315. };
  316.  
  317.  
  318.  
  319. // La funzione stampa la lista dei files a cominciare
  320. // dal valore specificato
  321. void WinOpen::PrintFiles() {
  322.  
  323.   size_t k;
  324.   short  nnum, y1;
  325.   struct xycoord poly[ 3 ];
  326.  
  327.   // Prima di tutto eseguo la cancellazione del contenuto della finestra
  328.   _setcolor( 15 );
  329.   _rectangle( _GFILLINTERIOR, x + 12, y + 42, x + 216, y + 148 );
  330.  
  331.   // Setto il colore per la stampa dei nomi dei files
  332.   _setcolor( 0 ); nnum = ( ( firstf + 9 ) < max_files ) ? ( firstf + 9 ) : max_files;
  333.  
  334.   // Stampo anche la ScrollBar
  335.   _rectangle( _GBORDER, x + 200, y + 45, x + 210, y + 145 );
  336.  
  337.   // Controllo se e' il primo files
  338.   if( ( firstf - 1 ) > 0 )  {
  339.  
  340.     // Setto le coordinate per fare il triangolino
  341.     poly[ 0 ].xcoord = x + 209;
  342.     poly[ 0 ].ycoord = y + 54;
  343.  
  344.     poly[ 1 ].xcoord = x + 201;
  345.     poly[ 1 ].ycoord = y + 54;
  346.  
  347.     poly[ 2 ].xcoord = x + 205;
  348.     poly[ 2 ].ycoord = y + 45;
  349.  
  350.     // Disegno il poligono
  351.     _polygon( _GFILLINTERIOR, 3, poly );
  352.   }
  353.  
  354.   // Stampo anche il triangolino in basso
  355.   if( nnum < max_files ) {
  356.  
  357.     // Setto i vertici del nuovo triangolino
  358.     poly[ 0 ].xcoord = x + 201;
  359.     poly[ 0 ].ycoord = y + 136;
  360.  
  361.     poly[ 1 ].xcoord = x + 209;
  362.     poly[ 1 ].ycoord = y + 136;
  363.  
  364.     poly[ 2 ].xcoord = x + 205;
  365.     poly[ 2 ].ycoord = y + 145;
  366.  
  367.     // Disegno il poligono
  368.     _polygon( _GFILLINTERIOR, 3, poly );
  369.   }
  370.  
  371.   // Stampo la lista dei files
  372.   for( k = firstf - 1, y1 = y + 48; k < nnum; k++, y1 += 10 ) {
  373.  
  374.     // Sposto il cursore
  375.     _moveto( x + 18, y1 );
  376.  
  377.     // Scrivo il nome
  378.     _outgtext( CorrectName( lista[ k ] ) );
  379.   }
  380.  
  381. };
  382.  
  383.  
  384. // La funzione stampa la lista dei drives a cominciare
  385. // dal valore specificato
  386. void WinOpen::PrintDrive() {
  387.  
  388.   char   driv[ 3 ];
  389.   size_t k;
  390.   short  nnum, y1;
  391.   struct xycoord poly[ 3 ];
  392.  
  393.   // Prima di tutto eseguo la cancellazione del contenuto della finestra
  394.   _setcolor( 15 );
  395.   _rectangle( _GFILLINTERIOR, x + 245, y + 42, x + 345, y + 148 );
  396.  
  397.   // Setto il colore per la stampa dei nomi dei files
  398.   _setcolor( 0 ); nnum = ( ( firstd + 9 ) < max_drive ) ? ( firstd + 9 ) : max_drive;
  399.  
  400.   // Stampo anche la ScrollBar
  401.   _rectangle( _GBORDER, x + 334, y + 45, x + 344, y + 145 );
  402.  
  403.   // Controllo se e' il primo files
  404.   if( ( firstd - 1 ) > 0 )  {
  405.  
  406.     // Setto le coordinate per fare il triangolino
  407.     poly[ 0 ].xcoord = x + 343;
  408.     poly[ 0 ].ycoord = y + 54;
  409.  
  410.     poly[ 1 ].xcoord = x + 335;
  411.     poly[ 1 ].ycoord = y + 54;
  412.  
  413.     poly[ 2 ].xcoord = x + 339;
  414.     poly[ 2 ].ycoord = y + 45;
  415.  
  416.     // Disegno il poligono
  417.     _polygon( _GFILLINTERIOR, 3, poly );
  418.   }
  419.  
  420.   // Stampo anche il triangolino in basso
  421.   if( nnum < max_drive ) {
  422.  
  423.     // Setto i vertici del nuovo triangolino
  424.     poly[ 0 ].xcoord = x + 335;
  425.     poly[ 0 ].ycoord = y + 136;
  426.  
  427.     poly[ 1 ].xcoord = x + 343;
  428.     poly[ 1 ].ycoord = y + 136;
  429.  
  430.     poly[ 2 ].xcoord = x + 339;
  431.     poly[ 2 ].ycoord = y + 145;
  432.  
  433.     // Disegno il poligono
  434.     _polygon( _GFILLINTERIOR, 3, poly );
  435.   }
  436.  
  437.   // Stampo la lista dei files
  438.   for( k = firstd - 1, y1 = y + 48; k < nnum; k++, y1 += 10 ) {
  439.  
  440.     // Sposto il cursore
  441.     _moveto( x + 251, y1 );
  442.  
  443.     // Creazione del drive attivo
  444.     driv[ 0 ] = _drives[ k ]; driv[ 1 ] = ':'; driv[ 2 ] = '\0';
  445.  
  446.     // Scrivo il nome
  447.     _outgtext( driv );
  448.   }
  449. };
  450.  
  451.  
  452. // La funzione data la stringa di lavoro inserisce il null eliminando
  453. // un ramo di direttorio
  454. void WinOpen::CTree() {
  455.  
  456.   size_t  j;
  457.  
  458.   // Inserisce un null al posto dell'ultimo slash, eliminando un direttorio
  459.   for( j = strlen( work_dir ) - 1; j > 0; j-- )
  460.     if( work_dir[ j ] == '\\' ) { work_dir[ j ] = '\0'; break; }
  461.  
  462. };
  463.  
  464. // Disegno della percentuale nella finestra di open files
  465. void WinOpen::bars( size_t flen, size_t act ) {
  466.  
  467.   short cx1, cy1, cx2, cy2;
  468.   float inc;
  469.  
  470.   cx1 = x  +  31;       // Ingombro
  471.   cy1 = y  + 160;       // della Barra del %
  472.   cx2 = x  + 351;
  473.   cy2 = y  + 170;
  474.  
  475.   inc = ( float( cx2 - cx1 ) / flen ) * act;
  476.  
  477.   // Setta il colore blue
  478.   _setcolor( 4 );
  479.   _rectangle( _GFILLINTERIOR, cx1, cy1, cx1 + (short)inc, cy2 );
  480.  
  481. };
  482.  
  483.  
  484. // La funzione Seleziona il file dato il tipo
  485. void WinOpen::Validate() {
  486.  
  487.   short dato;
  488.   int   ch;
  489.   char  uscita = FALSE;
  490.   char  mode = FALSE, right = FALSE;
  491.   char  directory[ 4 ];
  492.  
  493.   // Resetto la stringa contenente il nome del file
  494.   output.reset();
  495.  
  496.   // Attenzione prima prelevo il direttorio di lavoro
  497.   getcwd( work_dir, 63 );
  498.  
  499.   // Carico la lista dei files
  500.   LoadList();
  501.  
  502.   // Stampo la lista dei files e la selezione del primo
  503.   firstf = firstd = fval = dval = 1;
  504.   PrintFiles(); SelectFiles();
  505.   PrintDrive(); SelectDrive();
  506.  
  507.   // Attivo il rettangolo di selezione per la modalita' di lavoro sui files
  508.   _setcolor( 0 );
  509.   _rectangle( _GBORDER, x + 8, y + 38, x + 220, y + 152 );
  510.  
  511.   // Eseguo la lettura di un carattere alla volta
  512.   for( ;; ) {
  513.  
  514.     // Se il tasto e' stato premuto eseguo l'azione
  515.     while( !kbhit() ) {}
  516.  
  517.     // Verifico il tasto
  518.     switch( ch = getch() ) {
  519.  
  520.       case  0 : mode = TRUE;   break;
  521.       case 27 : uscita = TRUE; break;
  522.       case 80 : // Tasto down
  523.  
  524.            // Controllo se mode e' vero
  525.            if( mode ) {
  526.  
  527.              // Controllo se sto manipolando i drive o i files
  528.              if( right ) {
  529.  
  530.                // Controllo il valore rispetto al numero massimo di drive
  531.                if( dval < win_drive ) {
  532.  
  533.                  // Ristampo la lista dei drive
  534.                  dval++; PrintDrive(); SelectDrive();
  535.                }
  536.                else // Controllo quanti drive ci sono in lista
  537.  
  538.                  // Increemento il numero di item dal quale stampare
  539.                  if( ( firstd + 9 ) < max_drive ) {
  540.  
  541.                    // Stampo la lista dei drive
  542.                    firstd++; PrintDrive(); SelectDrive();
  543.                  }
  544.              }
  545.              else {
  546.  
  547.                // Controllo il valore
  548.                if( fval < win_files ) {
  549.  
  550.                  // Ristampo la lista dei files
  551.                  fval++; PrintFiles(); SelectFiles();
  552.                }
  553.                else // Controllo quanti files ci sono in lista
  554.  
  555.                  // Incremento il numero di item dal quale stampare
  556.                  if( ( firstf + 9 ) < max_files ) {
  557.  
  558.                    // Stampo la lista dei files
  559.                    firstf++; PrintFiles(); SelectFiles();
  560.                  }
  561.              }
  562.  
  563.              // Resetto il tasto speciale
  564.              mode = FALSE;
  565.            }
  566.         break;
  567.       case 72 : // Tasto up
  568.  
  569.            // Controllo se mode e' vero
  570.            if( mode ) {
  571.  
  572.              // Controllo se sto lavorando con la modalita' files
  573.              if( right ) {
  574.  
  575.                // Se fval e' valido seleziono il nome del drive
  576.                if( dval > 1 ) {
  577.  
  578.                  // Stampo la lista dei drive
  579.                  dval--; PrintDrive(); SelectDrive();
  580.                }
  581.                else { // Controllo il valore di firstd
  582.  
  583.                  if( firstd > 1 ) {
  584.  
  585.                    // Stampo il valore della lista dei drive
  586.                    firstd--; PrintDrive(); SelectDrive();
  587.                  }
  588.                }
  589.              }
  590.              else {
  591.  
  592.                // Se fval e' valido seleziono il nome del file
  593.                if( fval > 1 ) {
  594.  
  595.                  // Stampo la lista di files
  596.                  fval--;
  597.                  PrintFiles();
  598.                  SelectFiles();
  599.                }
  600.                else { // Controllo il valore di firstf
  601.  
  602.                  if( firstf > 1 ) {
  603.  
  604.                    // Stampo il valore della lista dei files
  605.                    firstf--;
  606.                    PrintFiles();
  607.                    SelectFiles();
  608.                  }
  609.                }
  610.              }
  611.  
  612.              // Resetto il tasto speciale
  613.              mode = FALSE;
  614.            }
  615.         break;
  616.  
  617.       case 77 : // Pressione del tasto destro spostamento nella selezione dei drive
  618.  
  619.            // Controllo se stavo gia' lavorando sui drive
  620.            if( !right ) {
  621.  
  622.              // Disattivo il rettangolo di selezione dei file
  623.              _setcolor( col_WOpen );
  624.              _rectangle( _GBORDER, x + 8, y + 38, x + 220, y + 152 );
  625.  
  626.              // Attivo il rettangolo di selezione dei drive
  627.              _setcolor( 0 );
  628.              _rectangle( _GBORDER, x + 238, y + 38, x + 352, y + 152 );
  629.            }
  630.  
  631.            // Setto a true la modalita' di lavoro nei drives
  632.            right = TRUE;
  633.         break;
  634.  
  635.       case 75 : // Pressione del tasto sinistro spostamento nella selezione dei files
  636.  
  637.