PDA

Visualizza la versione completa : [C] Percentuale di caricamento


Ov3rLo4d
03-11-2009, 23:56
#include <stdio.h>
#include <time.h>

void isort(int a[], int n){
int i;
int x=0;
int j=0;
for(i=1; i<n; i++){
x=a[i];
j=i;
while (j >0 && x< a[j-1]) {
a[j] = a[j-1];
j--;
}
a[j]= x;
}
}

int main(void)
{
clock_t start, end, dif;
float tempo=0;
int N=0;
int M=0;
printf("Inserisci la dimensione dell'array: \n");
scanf("%d",&N);
printf("Ora inserisci il range degli elementi: \n");
scanf("%d",&M);

int a[N]; // x isort

// ISORT****************
printf("\n\n\t\t***ISORT***\n\n");
start=clock();
isort(a,N);
end=clock();
dif=end-start;
tempo=(float)dif/(float)CLOCKS_PER_SEC;

return 0;
}



ho messo il sorgente per far funzionare l'insertion sort...

In pratica oltre a far misurare il tempo vorrei una barra di caricamento con percentuale...

es: [======== ] 50%

Solo che non so da dove cominciare...

Grazie a tutti

MItaly
04-11-2009, 00:05
http://forum.html.it/forum/showthread.php?s=&threadid=1306161

Ov3rLo4d
05-11-2009, 11:22
Ok, ora che ho il sorgente della barra:



#include <stdio.h>
#include <unistd.h>

typedef enum
{
false=0,
true=!false
} bool;

typedef struct
{
/* Delimitatore iniziale (es. [ )*/
char StartDelimiter;
/* Delimitatore finale (es. ] )*/
char EndDelimiter;
/* Blocco centrale (es. = )*/
char Block;
/* Ultimo blocco (es. > ) */
char CurBlock;
/* Flag che indica se mostrare la percentuale di avanzamento o meno */
bool PrintPercent;
} ProgressBarSettings;


void PrintProgressBar(unsigned int Width, double Max, double Pos, bool update, ProgressBarSettings * Settings);

int main()
{
int i;
/* Inizializza le impostazioni della barra */
ProgressBarSettings pbs;
pbs.StartDelimiter='[';
pbs.EndDelimiter=']';
pbs.Block='=';
pbs.CurBlock='>';
pbs.PrintPercent=true;
printf("Progress: ");
/* Mostra la barra vuota */
PrintProgressBar(40,80,0,false,&pbs);
for(i=0;i<=80;i++)
{
/* Attende la pressione di un tasto (funzione non-standard) */
sleep(1);
/* Aggiorna la barra di avanzamento */
PrintProgressBar(40,80,i,true,&pbs);
}
printf(" Done\n\n");
sleep(1);
return 0;
}

void PrintProgressBar(unsigned int Width, double Max, double Pos, bool update, ProgressBarSettings * Settings)
{
/* Blocchi da stampare */
unsigned int printBlocks=(unsigned int)(Width*Pos/Max);
/* Contatore */
unsigned int counter;
/* Se stiamo aggiornando una barra già esistente...*/
if(update)
{
/* ... ci posizioniamo all'inizio di essa per poi sovrascriverla. */
for(counter=Width+2+(Settings->PrintPercent?5:0);counter;counter--)
putchar('\b');
}
/* Stampa il delimitatore iniziale */
putchar(Settings->StartDelimiter);
/* Resetta il contatore */
counter=Width;
/* Stampa i tutti i blocchi meno 1; intanto decrementa il contatore,
in modo che alla fine in esso resterà il numero di spazi da stampare per riempire la barra */
for(;printBlocks>1;printBlocks--,counter--)
putchar(Settings->Block);
/* Stampa l'ultimo blocco; se l'operazione è completata usa il carattere normale, se no quello scelto per l'ultimo blocco */
putchar((Max==Pos)?Settings->Block:Settings->CurBlock);
/* Decrementa il contatore perché è stato stampato un altro blocco */
counter--;
/* Stampa gli spazi */
for(;counter;counter--)
putchar(' ');
/* Stampa il delimitatore finale */
putchar(Settings->EndDelimiter);
/* Eventualmente stampa anche la percentuale di avanzamento */
if(Settings->PrintPercent)
printf(" %3d%%",(int)(100*Pos/Max));
fflush(stdout);
};



Non so come implementarlo nel mio piccolo programma, in modo che carichi la barra a seconda del punto in cui è con l'esecuzione del programma.



#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void isort(int a[], int n){
int i;
int x=0;
int j=0;
for(i=1; i<n; i++){
x=a[i];
j=i;
while (j >0 && x< a[j-1]) {
a[j] = a[j-1];
j--;
}
a[j]= x;
}
}

int main(int argc, char** argv)
{
clock_t start, end, dif;
float tempo=0;
int N=0;
int M=0;
printf("Inserisci la dimensione dell'array: \n");
scanf("%d",&N);
printf("Ora inserisci il range degli elementi: \n");
scanf("%d",&M);

int a[N]; // x isort

// ISORT****************
printf("\n\n\t\t***ISORT***\n\n");
start=clock();
isort(a,N);
end=clock();
dif=end-start;
tempo=(float)dif/(float)CLOCKS_PER_SEC;
printf("\nTempo di esecuzione: %d\n",tempo);

return 0;
}

Spero di essere stato chiaro...

Grazie

MItaly
05-11-2009, 17:11
Dovresti trovare nel tuo programma dei punti in cui calcolare la percentuale di caricamento e quindi aggiornare la barra.

KrOW
05-11-2009, 18:26
Ciao ... Per fare quello che dici tu, hai bisogno di "prevedere" il numero delle operazioni da effettuare e, secondo quest' ultimo, aggiornare la barra. Ad esempio mettiamo caso tu voglia scrivere 50.000 caratteri su di un file e ne vuoi tracciare l' avanzamento con una barra. La barra in questione è composta da (esempio) 100 blocchi. Quindi ogni quante operazioni (in questo caso scritture di caratteri)viene riempito un blocco? Basta fare OperazioniTotali / NumeroBlocchi quindi 50.000/100= 50. Questo ci dice che ogni 50 operazioni, il numero di blocchi "pieni" aumenta di uno. Quindi è facile conoscere il numero dei blocchi "pieni" sapendo il numero totale di operazioni effettuate e il numero di operazioni per blocco: basta fare OperazioniEffettuate / OperazioniPerBlocco. Continuando con l' esempio precedente se siamo alla 40.000-esima operazione, possiamo ottenere il numero di blocchi "pieni" così 40.000/50 = 80.Nel tuo caso, il discorso è diverso siccome non è possibile prevedere (senza effettuarle) il numero di operazioni da effettuare (che cambia a secondo dei valori dell' array), però conosci il numero degli elementi dell' array, quindi potresti aggiornare la barra ad ogni elemento ordinato con una codice del genere:


#include <stdio.h>
#include <time.h>
#include <memory.h>

typedef unsigned int uint;

typedef struct
{
/* Carattere che rappresenta un blocco riempito della barra */
char cUnitFillBlock;
/* Carattere che rappresenta un blocco vuoto della barra */
char cUnitEmptyBlock;
/* Carattere iniziale della barra */
char cStartDelimitator;
/* Carattere finale della barra */
char cEndDelimitator;
/* Numero dei blocchi che costitutiscono la barra */
uint nTotalBlocksCount;
/* Operazioni totali da effettuare */
uint nTotalOperations;
/* Numero di operazioni per blocco */
double fOperationsPerBlock;
/* Numero delle operazione totali effettuate */
uint nCurrOperation;
/* Numero di blocchi "pieni" */
uint nFilledBlock;
/* La barra intesa come stringa (es. "[========]") */
char* szBar;
} ProgressBar;

void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock='=', char unitEmptyBlock=' ', char startDel='[', char endDel=']' );
void CleanProgressBar( ProgressBar* pPb );
void ShowProgressBar( ProgressBar* pPb );
bool UpdateProgressBar( ProgressBar* pPb, uint opToAdd=1 );
void isort( int a[], int n );

#define ARRAY_SIZE 0xFFFF

int main()
{
srand( time(0) );
int a[ARRAY_SIZE];
// Riempie l' array con valori casuali
for( int i=0; i<ARRAY_SIZE; ++i )
a[i] = rand() % ARRAY_SIZE;
isort( a, ARRAY_SIZE );
return 0;
}

void isort( int a[], int n )
{
ProgressBar pb;
// Imposta i dati interni della barra
InitializeProgressBar( &pb, 10, n-1 );
int i, x=0, j=0;
for( int i=1; i<n; i++ )
{
x = a[i];
j = i;
while( j>0 && (x<=a[j-1]) )
{
a[j] = a[j-1];
j--;
}
a[j] = x;
// Se la barra è cambiata (il numero di blocchi "pieni" è cambiato)
if( UpdateProgressBar( &pb, 1 ) )
{
// Cancella lo schermo
system("cls");
// Mostra a video la nuova barra
ShowProgressBar( &pb );
}
}
CleanProgressBar( &pb );
}
void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock, char unitEmptyBlock, char startDel, char endDel )
{
// Imposta a 0 il numero di blocchi pieni
pPb->nFilledBlock = 0;
// Imposta il numero dei blocchi totali, il numero totale di operazioni, i caratteri per i delimitatori e per i blocchi
pPb->nTotalBlocksCount = totBlocks;
pPb->nTotalOperations = totOperations;
pPb->cUnitFillBlock = unitBlock;
pPb->cUnitEmptyBlock = unitEmptyBlock;
pPb->cStartDelimitator = startDel;
pPb->cEndDelimitator = endDel;
// Calcola il numero di operazioni per singolo blocco
pPb->fOperationsPerBlock = (double)pPb->nTotalOperations / (double)pPb->nTotalBlocksCount;
// Imposta a 0 il numero delle operazioni effettuate fin' ora
pPb->nCurrOperation = 0;
// Alloca memoria per la "barra-stringa", ne imposta i delimitatori e la riempe con blocchi "vuoti"
pPb->szBar = (char*)malloc( sizeof(char) * pPb->nTotalBlocksCount + 2 + 1 );
memset( pPb->szBar, pPb->cUnitEmptyBlock, sizeof(char)*(pPb->nTotalBlocksCount + 2 + 1) );
pPb->szBar[0] = pPb->cStartDelimitator;
pPb->szBar[ pPb->nTotalBlocksCount + 1] = pPb->cEndDelimitator;
pPb->szBar[ pPb->nTotalBlocksCount + 2] = '\0';
}

void CleanProgressBar( ProgressBar* pPb )
{
if( pPb->szBar )
free( pPb->szBar );
pPb->szBar = NULL;
}

void ShowProgressBar( ProgressBar* pPb )
{
printf( "%s\n", pPb->szBar );
}


bool UpdateProgressBar( ProgressBar* pPb, uint opToAdd )
{
// Aggiorna il numero delle operazioni effettuate
pPb->nCurrOperation += opToAdd;
// Dammi il numero di blocchi pieni secondo il nuovo numero delle operazioni
uint iCurrLastFilledBlock = (uint)((double)pPb->nCurrOperation / pPb->fOperationsPerBlock);
// Se il numero di blocchi pieni (appena calcolato) è maggiore di quello memorizzato
if( iCurrLastFilledBlock > pPb->nFilledBlock )
{
// Aggiorna il numero dei blocchi pieni memorizzato
pPb->nFilledBlock = pPb->nCurrOperation / pPb->fOperationsPerBlock;
// Aggiorna la barra-stringa
memset( pPb->szBar+1, pPb->cUnitFillBlock, sizeof(char) * pPb->nFilledBlock );
return true;
}
else
return false;
}
Considera che su questo codice, non ho effettuato molti controlli, quindi chiedo scusa se ci sono errori inoltre non viene stampato la percentuale, ma capendo il codice, non è difficile aggiungere tale modifica ...

Ov3rLo4d
05-11-2009, 18:55
Ciao, prima di tutto ti ringrazio per l'interesse e lo sbattimento ^^

Ho provato a compilare per vedere... ho corretto piccoli errori (quelli che ho capito XD)

Correct source:



#include <stdio.h>
#include <time.h>
#include <memory.h>

typedef unsigned int uint;

typedef struct
{
/* Carattere che rappresenta un blocco riempito della barra */
char cUnitFillBlock;
/* Carattere che rappresenta un blocco vuoto della barra */
char cUnitEmptyBlock;
/* Carattere iniziale della barra */
char cStartDelimitator;
/* Carattere finale della barra */
char cEndDelimitator;
/* Numero dei blocchi che costitutiscono la barra */
uint nTotalBlocksCount;
/* Operazioni totali da effettuare */
uint nTotalOperations;
/* Numero di operazioni per blocco */
double fOperationsPerBlock;
/* Numero delle operazione totali effettuate */
uint nCurrOperation;
/* Numero di blocchi "pieni" */
uint nFilledBlock;
/* La barra intesa come stringa (es. "[========]") */
char* szBar;
} ProgressBar;

void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock='=', char unitEmptyBlock=' ', char startDel='[', char endDel=']' );
void CleanProgressBar( ProgressBar* pPb );
void ShowProgressBar( ProgressBar* pPb );
bool UpdateProgressBar( ProgressBar* pPb, uint opToAdd=1 );
void isort( int a[], int n );

#define ARRAY_SIZE 0xFFFF

int main()
{
srand( time(0) );
int a[ARRAY_SIZE];
// Riempie l' array con valori casuali
int i;
for(i=0; i<ARRAY_SIZE; ++i )
a[i] = rand() % ARRAY_SIZE;
isort( a, ARRAY_SIZE );
return 0;
}

void isort( int a[], int n )
{
ProgressBar pb;
// Imposta i dati interni della barra
InitializeProgressBar( &pb, 10, n-1 );
int i, x=0, j=0;
for(i=1; i<n; i++ )
{
x = a[i];
j = i;
while( j>0 && (x<=a[j-1]) )
{
a[j] = a[j-1];
j--;
}
a[j] = x;
// Se la barra è cambiata (il numero di blocchi "pieni" è cambiato)
if( UpdateProgressBar( &pb, 1 ) )
{
// Cancella lo schermo
system("cls"); // Su unix mi sa che questo non va
// Mostra a video la nuova barra
ShowProgressBar( &pb );
}
}
CleanProgressBar( &pb );
}
void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock, char unitEmptyBlock, char startDel, char endDel )
{
// Imposta a 0 il numero di blocchi pieni
pPb->nFilledBlock = 0;
// Imposta il numero dei blocchi totali, il numero totale di operazioni, i caratteri per i delimitatori e per i blocchi
pPb->nTotalBlocksCount = totBlocks;
pPb->nTotalOperations = totOperations;
pPb->cUnitFillBlock = unitBlock;
pPb->cUnitEmptyBlock = unitEmptyBlock;
pPb->cStartDelimitator = startDel;
pPb->cEndDelimitator = endDel;
// Calcola il numero di operazioni per singolo blocco
pPb->fOperationsPerBlock = (double)pPb->nTotalOperations / (double)pPb->nTotalBlocksCount;
// Imposta a 0 il numero delle operazioni effettuate fin' ora
pPb->nCurrOperation = 0;
// Alloca memoria per la "barra-stringa", ne imposta i delimitatori e la riempe con blocchi "vuoti"
pPb->szBar = (char*)malloc( sizeof(char) * pPb->nTotalBlocksCount + 2 + 1 );
memset( pPb->szBar, pPb->cUnitEmptyBlock, sizeof(char)*(pPb->nTotalBlocksCount + 2 + 1) );
pPb->szBar[0] = pPb->cStartDelimitator;
pPb->szBar[ pPb->nTotalBlocksCount + 1] = pPb->cEndDelimitator;
pPb->szBar[ pPb->nTotalBlocksCount + 2] = '\0';
}

void CleanProgressBar( ProgressBar* pPb )
{
if( pPb->szBar )
free( pPb->szBar );
pPb->szBar = NULL;
}

void ShowProgressBar( ProgressBar* pPb )
{
printf( "%s\n", pPb->szBar );
}


bool UpdateProgressBar( ProgressBar* pPb, uint opToAdd )
{
// Aggiorna il numero delle operazioni effettuate
pPb->nCurrOperation += opToAdd;
// Dammi il numero di blocchi pieni secondo il nuovo numero delle operazioni
uint iCurrLastFilledBlock = (uint)((double)pPb->nCurrOperation / pPb->fOperationsPerBlock);
// Se il numero di blocchi pieni (appena calcolato) è maggiore di quello memorizzato
if( iCurrLastFilledBlock > pPb->nFilledBlock )
{
// Aggiorna il numero dei blocchi pieni memorizzato
pPb->nFilledBlock = pPb->nCurrOperation / pPb->fOperationsPerBlock;
// Aggiorna la barra-stringa
memset( pPb->szBar+1, pPb->cUnitFillBlock, sizeof(char) * pPb->nFilledBlock );
return true;
}
else
return false;
}


ho anche notato quel system("cls") che dovrebbe essere un comando DOS... mi ero dimenticato di dire che sono sotto Unix, più precisamente sotto Ubuntu... con cosa lo posso sostituire? clear? oppure devo cambiare proprio la funzione?

Ti mostro anche l'output di GCC:



barrasort.c:31: error: expected ‘;’, ‘,’ or ‘)’ before ‘=’ token
barrasort.c:34: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘UpdateProgressBar’
barrasort.c:78: warning: conflicting types for ‘InitializeProgressBar’
barrasort.c:55: note: previous implicit declaration of ‘InitializeProgressBar’ was here
barrasort.c: In function ‘InitializeProgressBar’:
barrasort.c:94: warning: incompatible implicit declaration of built-in function ‘malloc’
barrasort.c: In function ‘CleanProgressBar’:
barrasort.c:104: warning: incompatible implicit declaration of built-in function ‘free’
barrasort.c: At top level:
barrasort.c:114: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘UpdateProgressBar’


mancano , ; o ) (sembra una faccina XD) ma dove?


Grazie mille ancora!

oregon
05-11-2009, 19:25
I valori di default usati per alcuni argomenti di queste funzioni (in rosso)

void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock='=', char unitEmptyBlock=' ', char startDel='[', char endDel=']' );

UpdateProgressBar( ProgressBar* pPb, uint opToAdd=1 );

non puoi usarli in C ... semmai in C++.

Ov3rLo4d
05-11-2009, 19:34
Grazie oregon.

Il problema è che non so nulla di C++. Quindi cosa devo mettere al posto dei valori di default? dopo cena provo a pasticciare un po', ma dubito di venirne a capo.

oregon
05-11-2009, 19:37
Niente ... utilizza le funzioni come sai in C eliminando la parte segnata ...

KrOW
05-11-2009, 19:38
Mi dovete perdonare, ma essendo abituato con il C++, mi dimentico di quasi sempre "aggiustare" il relativo codice compilabile in C (senza contare che mi son dimenticato di includere un header e la definizione di bool). Questo è il codice corretto:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>

typedef unsigned int uint;

typedef enum
{
false, true
} bool;

typedef struct
{
/* Carattere che rappresenta un blocco riempito della barra */
char cUnitFillBlock;
/* Carattere che rappresenta un blocco vuoto della barra */
char cUnitEmptyBlock;
/* Carattere iniziale della barra */
char cStartDelimitator;
/* Carattere finale della barra */
char cEndDelimitator;
/* Numero dei blocchi che costitutiscono la barra */
uint nTotalBlocksCount;
/* Operazioni totali da effettuare */
uint nTotalOperations;
/* Numero di operazioni per blocco */
double fOperationsPerBlock;
/* Numero delle operazione totali effettuate */
uint nCurrOperation;
/* Numero di blocchi "pieni" */
uint nFilledBlock;
/* La barra intesa come stringa (es. "[========]") */
char* szBar;
} ProgressBar;

void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock, char unitEmptyBlock, char startDel, char endDel );
void CleanProgressBar( ProgressBar* pPb );
void ShowProgressBar( ProgressBar* pPb );
bool UpdateProgressBar( ProgressBar* pPb, uint opToAdd );
void isort( int a[], int n );

#define ARRAY_SIZE 0xFFFF

int main()
{
int i;
int a[ARRAY_SIZE];
srand( time(NULL) );
// Riempie l' array con valori casuali
for( i=0; i < ARRAY_SIZE; ++i )
a[i] = rand() % ARRAY_SIZE;
isort( a, ARRAY_SIZE );
return 0;
}

void isort( int a[], int n )
{
ProgressBar pb;
int i, x=0, j=0;
// Imposta i dati interni della barra
InitializeProgressBar( &pb, 10, n-1, '=', ' ', '[', ']' );
for( i=1; i<n; i++ )
{
x = a[i];
j = i;
while( j>0 && (x<=a[j-1]) )
{
a[j] = a[j-1];
j--;
}
a[j] = x;
// Se la barra è cambiata (il numero di blocchi "pieni" è cambiato)
if( UpdateProgressBar( &pb, 1 ) )
{
// Cancella lo schermo
// system("cls");
// Mostra a video la nuova barra
ShowProgressBar( &pb );
}
}
CleanProgressBar( &pb );
}
void InitializeProgressBar( ProgressBar* pPb, uint totBlocks, uint totOperations, char unitBlock, char unitEmptyBlock, char startDel, char endDel )
{
// Imposta a 0 il numero di blocchi pieni
pPb->nFilledBlock = 0;
// Imposta il numero dei blocchi totali, il numero totale di operazioni, i caratteri per i delimitatori e per i blocchi
pPb->nTotalBlocksCount = totBlocks;
pPb->nTotalOperations = totOperations;
pPb->cUnitFillBlock = unitBlock;
pPb->cUnitEmptyBlock = unitEmptyBlock;
pPb->cStartDelimitator = startDel;
pPb->cEndDelimitator = endDel;
// Calcola il numero di operazioni per singolo blocco
pPb->fOperationsPerBlock = (double)pPb->nTotalOperations / (double)pPb->nTotalBlocksCount;
// Imposta a 0 il numero delle operazioni effettuate fin' ora
pPb->nCurrOperation = 0;
// Alloca memoria per la "barra-stringa", ne imposta i delimitatori e la riempe con blocchi "vuoti"
pPb->szBar = (char*)malloc( sizeof(char) * pPb->nTotalBlocksCount + 2 + 1 );
memset( pPb->szBar, pPb->cUnitEmptyBlock, sizeof(char)*(pPb->nTotalBlocksCount + 2 + 1) );
pPb->szBar[0] = pPb->cStartDelimitator;
pPb->szBar[ pPb->nTotalBlocksCount + 1] = pPb->cEndDelimitator;
pPb->szBar[ pPb->nTotalBlocksCount + 2] = '\0';
}

void CleanProgressBar( ProgressBar* pPb )
{
if( pPb->szBar )
free( pPb->szBar );
pPb->szBar = NULL;
}

void ShowProgressBar( ProgressBar* pPb )
{
printf( "%s\n", pPb->szBar );
}


bool UpdateProgressBar( ProgressBar* pPb, uint opToAdd )
{
uint iCurrLastFilledBlock;
// Aggiorna il numero delle operazioni effettuate
pPb->nCurrOperation += opToAdd;
// Dammi il numero di blocchi pieni secondo il nuovo numero delle operazioni
iCurrLastFilledBlock = (uint)((double)pPb->nCurrOperation / pPb->fOperationsPerBlock);
// Se il numero di blocchi pieni (appena calcolato) è maggiore di quello memorizzato
if( iCurrLastFilledBlock > pPb->nFilledBlock )
{
// Aggiorna il numero dei blocchi pieni memorizzato
pPb->nFilledBlock = pPb->nCurrOperation / pPb->fOperationsPerBlock;
// Aggiorna la barra-stringa
memset( pPb->szBar+1, pPb->cUnitFillBlock, sizeof(char) * pPb->nFilledBlock );
return true;
}
else
return false;
}
Per quel che riguarda il comnado DOS "cls", è disponibile (appunto) solo su windows/DOS. Tieni a mente che dovresti evitare la chiamata a tale funzione, io l' ho inserita solo per semplificare il codice (pensavo che tu lavoravi su un sistema windows) ... Mi dispiace ma linux per me è sconosciuto quindi non posso aiutarti su questo ...

Loading