Newsgroup: it.comp.programmare.win32
Titolo: [C++ builder] Sincronizzare esecuzione

Salve,
Avre il seguente codice, che sposta verso destra due componenti a velocit� 
diverse:
TShape1->Left++;
Sleep(50);
TShape2->Left ++;
Sleep(100);
Ma avrei bisogno di eseguirle contemporaneamente. Forse servono i thread? 
Potreste farmi un esempio semplice da usare come spunto?
Fino ad ora avevo fissato un valore unico per Sleep e variato il numero di 
pixel nell'incremento, ma negli spostamenti diagonali diventa un po 
scattoso, spostandomi invece di un pixel alla volta � pi� fluido ma non 
rispetta la velocit� che serve a me.
Saluti 

Aggiungo un'altra domanda:
Per simulare lo spostamento di un TShape lungo una diagonale che per� non 
abbia un inclinazione simmetrica (ovvero non sarebbe inclinata perfettamente 
a 45 gradi), ma piuttosto, pi� orizzontale che verticale, fino ad ora avevo 
pensato ad esempio di decrementare di un pixel il Top per ogni due 
incrementi del Left, e il risultato � corretto, solo che anche qui nasce il 
problema della scattosit�.
Anche in questo caso forse la soluzione � l'uso dei thread, ma i thread 
vanno bene anche se l'operazione viene effettuata sullo stesso oggetto?
Qualcosa del tipo:
TShape1->Left++
Sleep(20);
TShape1->Top--;
Sleep(40);
Trasformata in due processi distinti ed eseguiti contemporaneamente, 
riuscirebbe a dare l'effetto che intendo io? 

 problema della scattositï¿œ.
Ma perchï¿œ invece di sleep non usi un TTimer?
Cosï¿œ sarebbe tutto molto piï¿œ semplice...
//----------------------------------------------------------------
TTimer *AniClock;
AniClock = new(TTimer);
AniClock->Interval = 10; // 10 millisecondi; il tempo e
int SpeedX = 20;	 // le velocitï¿œ dovrai regolarle tu,
int SpeedY = 40;	 // queste sono solo per fare un esempio
//----------------------------------------------------------------
//	ecc. ecc...
//----------------------------------------------------------------
void __fastcall TForm1::AniClockTimer(TObject *Sender)
{
TShape1->Left += SpeedX;
TShape1->Top -= SpeedY;
}

 
La gestione della grafica deve avvenire sempre nel thread principale 
(intendo come output su schermo, le eventuali elaborazioni possono anche 
essere eseguite in asincrono), quindi nel tuo caso i thread non servono. 
Usare poi lo sleep() in quel modo è sbagliato perché stai congelando 
l'applicazione. Meglio usare un timer e modificare le coordinate al 
verificarsi dell'evento. Poi ti conviene usare valori float (o double) 
per memorizzare sia la posizione che l'incremento necessario e assegnare 
la coordinata previa conversione in intero.
Se usi le GDI la scattosità l'avrai sempre nel passaggio da un pixel 
all'altro, specialmente a basse velocità di spostamento.
Dai un'occhiata ai sorgenti di un semplice screensaver su
http://www.ennepisoft.it
e prova la differenza tra D3D e GDI (o directX).
Ciao

 Cos� sarebbe tutto molto pi� semplice...
Umh... prover� ad usare TTimer, ma mi sa che il problema della scattosit� 
negli spostamenti diagonali si noter� ugualmente.
Grazie per l'esempio. 

 Ciao
D3D e DirectX vanno allo stesso modo, GDI scatta un po'.
Ma Direct3D � una versione di DirectX per immagini 3D? 

Avrei una domanda: per interrompere l'esecuzione devo disabilitare il 
componente?
Ho provato questo codice in quale dovrebbe far scattare una volta soltanto 
l'evento OnTimer per ogni TTimer, ma invece l'evento si verifica pi� volte:
TTimer* Vel[3];
void __fastcall TForm1::fun(TObject* Sender) {
    int i = ((TTimer*)Sender)->Tag;
    Application->MessageBox(IntToStr(i).c_str() , " ", MB_OK);
    Vel[i]->Enabled = false;
}
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    for (int i = 0; i < 3; i++) {
        Vel[i] = new TTimer(Form1);
        Vel[i]->Interval = (i + 1) * 1000;
        Vel[i]->OnTimer = Form1->fun;
        Vel[i]->Tag = i;
    }
}
Grazie 


Spostando la disabilitazione prima della MessageBox, funziona.
Confermi comunque che bisogna disabilitare il controllo per interrompere il 
verifcarsi degli eventi OnTimer? 

 verifcarsi degli eventi OnTimer? 
Confermo io, metti Enabled a FALSE e l'evento non "eventa" pi� :-)

 Confermo io, metti Enabled a FALSE e l'evento non "eventa" pi� :-)
Ho visto che anche con Interval = 0 non scatta pi�