Newsgroup: it.comp.java
Titolo: J2ME e paint!

Visto che si era aperta una discussione su J2ME, io ho questo problema: ricevo dei dati da un canale di comunicazione, li memorizzo, li elaboro e li disegno sul canvas; nel mentre sul canale ne stanno arrivando altri, quindi il tutto si ripete tante volte.
Ora, come disegnare? Secondo la "logica" che c'e' dietro alla documentazione, dopo ogni invocazione di repaint() andrebbe invocato il metodo serviceRepaints(), che dovrebbe essere bloccante finche' tutte le richieste di repaint non siano state servite. In questo modo dovrebbe essere garantito che ogni frame venga visualizzato.
In alternativa, ho letto del metodo callSerially() ma non ho ancora approfondito i vantaggi/svantaggi derivanti dal suo uso.
Il mio problema e' che alla fine vado a cambiare dei dati che vengono usati anche dal paint, col risultato che l'applicazione e' tutt'altro che fluida nel suo scorrere delle immagini..... :(
Ascolto tutti i suggerimenti!
CarMas

 che fluida nel suo scorrere delle immagini..... :(
Non ho capito molto bene il dilemma. Usando i metodi della GameCanvas
che ti ho indicato poc'anzi, comunque, utilizzi la tecnica del double
buffering: disegni su un offscreen buffer, che non è quello che viene
visualizzato in quel momento, per poi "scambiarlo" alla fine, tramite
flushGraphics(). Questo dovrebbe consentirti una maggiore fluidità.
Personalmente però devo ancora inquadrare quest'ultimi metodi con una
buona gestione e sincronizzazione dei Thread.
-- 
~ Se i sintomi persistono, insultare il medico.


Come ti ha suggerito ZERO, il double buffer e' sicurmanete la strada
da seguire se vuoi fare animazioni.
in aggiunta normalmente quando si devono disegnare dei dati che
variano rapidamente si fa in modo che sia il metodo che disegna che va
a pescare i dati quando gli servono, e non il contrario.
Esempio:
ho un classe  A(eventualemtne in un thread) che mi calcola la
traiettoria di n corpi (usando runge kutta o un qualche altro
algoritmo)
un altra classe B(in eventualmente un altro thread) si occupa di
disegnare quesi n corpi sullo schermo.
ora: se tu ogni volta che finisci di calcolare le posizioni degli n
corpi li dai in pasto a B rischi che se non ha gia' finito di
disegnare i corpi nella posizione precedente viene fuori una cosa non
coerente (i primi k corpi nella posizione precedente, i n-k sucessivi
nella posizione nuova). insomma non va bene.
Invece se fai in modo che si la classe B a chiedere la posizione
corrente dei corpi subito prima di disegnarli riesci a tenere un
disegno coerente, anche se poi magari non riesci a visualizzare tutti
i punti, ma solo uno ogni tot. (che poi e' il problema dei videogiochi
quando hai una GPU pessima, vanno a scatti perche' usano quest'ultimo
metodo).
va da se che le due classi non devono per forza essere sulla stessa
macchina.
inoltre (e' abbastanza ovvio, ma...) la classe A deve avere la
possibilita' di mantenere le posizioni correnti finche' ha calcolato
quelle nuove, e quando ha finito di calcolarle riuscire ad aggiornare
le correnti in modo atomico (per evitare che la classe B legga meta'
dei dati vecchi e meta' dei nuovi).
Ciao Jack

 a pescare i dati quando gli servono, e non il contrario.
Penso che sia questa la strada da seguire nel mio caso, con tutte le considerazioni e i casi a cui prestare attenzione che hai giustamente sottolineato!
Domani inizio a lavorarci su e vedo cosa riesco a tirare fuori!
Saluti
CarMas

 Beh, sul MIDP 1.0 funzionava da dio. :)
Fammi un esempio di come lo usavi sul midp1, poi valuto se approfittarne ;P
Saluti
CarMas

 Fammi un esempio di come lo usavi sul midp1, poi valuto se approfittarne ;P
http://www.mokabyte.it/2004/01/j2me-games-1.htm
:)


 
http://www.mokabyte.it/2004/01/j2me-games-1.htm
E' proprio quil mio dubbio, ho letto sia questa pagina che un'altra e vengono usate due tecniche diverse!
Ovvero, su mokabyte mette la chiamata a callSerially dentro al metodo run
public void run() {
  //operazioni del motore di gioco
  //aggiornamento grafico
  repaint();
 if(gameLoop) display.callSerially(this);
}
e il paint() e' normale operazioni di disegno.
Su 
http://www.developer.com/java/j2me/print.php/10934_1561591_8
 invece trovo scritto "An alternative to serviceRepaints() is calling callSerially() at the end of the paint() method" ed infatti nel codice di esempio riporta:
public void run () {
  // ...elaborazione...
  repaint ();
}
e il paint diventa
public void paint (Graphics g) {
   //...disegno...
   display.callSerially (this);
}
Ora... da qualcuno che l'ha usato, quale strada ha scelto? c'e' differenza nei due casi? 
Piccoli suggerimenti cosi' :P
Saluti
CarMas

 e vengono usate due tecniche diverse!
Ma tu mi hai chiesto come io lo usavo nel MIDP 1, ed io ti ho risposto
:)
-- 
~ Il futuro è nelle nostre mani. Purtroppo.