Newsgroup: it.comp.java
Titolo: Un piccolo aiuto sulle canvas?

Ciao,
sto facendo un'applicazione java sulla quale č possibile disegnare una linea 
tramite la pressione dei tasti del cursore. Fin qui č facile: prendo una 
canvas e ci disegno delle linee a seconda delle pressioni dei tasti. Il 
problema č che ora vorrei far uscire un cursore (ad esempio un pallino) nel 
punto in cui sono arrivato. Il problema č questo: se disegno il pallino, 
ogni volta che muovo il cursore mi resta la traccia del cursore precedente; 
se voglio cancellarlo dovrei cancellare il pallino precedente per poi fare 
il nuovo. Perň se lě c'č passata la mia linea, cancello pure il pezzo di 
linea che intersecava il precedente pallino!
Allora ho pensato che potrei o avere due canvas trasparenti sovrapposte (ma 
pare non sia possibile farlo) oppure dovrei mantenermi in una canvas di 
"appoggio" il disegno senza pallino e poi calare nella vera e propria canvas 
il disegno che ho nella canvas d'appoggio piů il cursore. Il problema č che 
non ho idea di come fare. Mi potete aiutare? Grazie di cuore.
-- 
Catman (r)
cat...@buythesepixels.com
http://www.buythesepixels.com
 (The cheapest pixels in the world)


In questo momento non ho molto tempo per risponderti nel dettaglio,
comunque considera il fatto che, normalmente, le applicazioni con
funzionalita' simili alle tue mantengono una collezione di oggetti
che rappresentano "logicamente" il disegno effettuato.
Ogni oggetto "logico" ha poi la responsabilita' di disegnarsi sul
Canvas e in questo modo hai anche la possibilita' di definire
un oggetto Cursore (le cui coordinate ridefinirai alla bisogna) e
che rappresentera' se stesso sul Canvas come un pallino (o come
qualsiasi altra cosa...).
Si tratta solo (si fa per dire!) di modellare un po' piu' ad
oggetti la tua soluzione.
Ciao!
Roberto

> problema è che non ho idea di come fare. Mi potete aiutare? Grazie di 


 ha scritto nel messaggio
news:QMihf.4250$S6.6...@twister2.libero.it...

Io mi sono ritrovato con il tuo stesso problema, dovevo fre un'applet che
disegnava ma tutte le volte che dovevo camcellare qualcosa spariva una parte
del disegno precedente.
Ti do una parte di codice che ho usato:
private void ridisegnaVecchio(Graphics gra, Vector tra){
        //funzione che mi ridisegna tutto quello che c'era prima, prendendo
i
        //dati dal vettore tra
        tratto t=null;
        if (tra.size()==0){
            //sono nel caso di vettore vuoto quindi cancello tutto
            gra.setColor(Color.WHITE);
            gra.fillRect(0,0,  gra.getClip().getBounds().width,
gra.getClip().getBounds().height);
        }
        else{
            for (int i=0; i<tra.size(); i++){
                t=(tratto)tra.get(i);
                gra.setColor(t.colore);
                if (t.rettangolo==true){
                    //disegno il rettangolo, da ricordarsi che una riga č
semplicemente
                    //un insieme di rettangoli
                    gra.fillRect(t.xPartenza,t.yPartenza,t.larghezza,
t.altezza);
                }
                else{
                    //disegno l'ovale
                    gra.fillOval(t.xPartenza,t.yPartenza,t.larghezza,
t.altezza);
                }
            }
        }
    }
"tra" non č altro che un vettore di oggetti che descrivono in pieno quello
che c'era disegnato prima.
Ricordati di agigungere ogni volta che finisci un disegno, i parametri
corretti nel vettore "tra".
Ciao e buon lavoro
Vinsanto

 
ehm...non proprio object-oriented, per la verita'.
Si otterrebbe un'applicazione *molto* piu' robusta se il vettore
"tra" conteness oggetti di una gerarchia di classi creata ad-hoc
per modellare le tipologie di "figure" da disegnare.
Il capostipite di tale gerarchia, magari chiamato proprio Figura,
potrebbe essere una classe astratta del tipo:
public abstract class Figura
{
   protected Color background;
   protected Color foreground;
   [...]
   public abstract void render(Graphics gra);
   [...]
}
da cui derivare le classi concrete delle figure:
public class Rettangolo extends Figura
{
   private int xPartenza;
   private int yPartenza;
   private int larghezza;
   private int altezza;
   [...]
   public abstract void render(Graphics gra)
   {
     gra.setColor(foreground);
     gra.fillRect(xPartenza, yPartenza, larghezza, altezza);
   }
   [...]
}
public class Ovale extends Figura
{
   private int xPartenza;
   private int yPartenza;
   private int larghezza;
   private int altezza;
   [...]
   public abstract void render(Graphics gra)
   {
     gra.setColor(foreground);
     gra.fillOval(xPartenza, yPartenza, larghezza, altezza);
   }
   [...]
}
Ovviamente, per ogni classe sara' opportuno definire
appositi costruttori...
E lo snippet che hai postato diventerebbe:
private void ridisegnaVecchio(Graphics gra, Vector tra)
{
   if (tra.size()==0)
   {
     // sono nel caso di vettore vuoto quindi cancello tutto
     gra.setColor(Color.WHITE);
     gra.fillRect(0, 0,
                  gra.getClip().getBounds().width,
                  gra.getClip().getBounds().height);
   }
   else
   {
     for (Iterator i = tra.iterator(); i.hasNext();)
     {
       Figura t = (Figura) i.next();
       r.render(gra);
     }
   }
}
Cosi' mi piace di piu'! ;)
Ciao!
Roberto

 Roberto
Grazie mille sei stato gentilissimo
Ciao
Vinsanto

 tutto il resto ad una implementazione cosi fatta.
Non solo: puoi aggiungere nuovi tipi derivati da Figura senza per questo
dover modificare la porzione di codice con il ciclo di rendering,
cosa che invece saresti costretto a fare nella tua versione.
Ciao!
Roberto