Newsgroup: it.comp.java
Titolo: Grafica 2D

Innanzitutto vi dico quello che devo fare: in un JFrame devo disegnare dei
semplicissimi rettangoli colorati di diverso colore  che poi cambieranno
dimensione durante l'esecuzione dell'applicazione.
La mia idea era di fare
un jpanel in cui mettere questi quadrati, così ho iniziato a spulciare la
documentazione alla ricerca di quello che mi serve e....ho capito poco o
nulla. Ho guardato l'esempio sun del tutorial (ShapeDemo2D) e ho trovato le
istruzioni per creare il rettangolo come serve a me g2.fill(new
Rectangle2D.Double(x, y, w, h)), però non capisco bene "quello che c'è
attorno" perchè nel tutorial imho non c'è spiegato un granchè. Devo per
forza mettere tutte le operazioni di disegno all'interno del metodo
paint()? Così facendo però mi ricrea ogni volta tutti gli oggetti? Io
vorrei definire i miei rettangoli (e le relative proprietà quali per
esempio il colore) solo alla creazione del frame, e poi poter solamente
modificare la dimensione, in modo che l'applicazione non sia troppo lenta e
pesante. Ah...non è un'applet, è un'applicazione vera e propria e sto
usando le swing.
Sto dicendo cose giuste oppure non ho proprio capito
nulla? Avete qualche link che può aiutarmi?
Grazie
Lis
--------------------------------
Inviato via 
http://usenet.iol.it

prima di tutto, se devi semplicemente disegnare dei rettangoli colorati,
puoi affidarti alla vecchia Graphics, che gira anche su vecchi JDK.
Invece di utilizzare un JPanel, estendi un Container che è AWT e che è più
snello.
Ridefinisci il metodo paint(Graphics g) e li fai il ridisegno delle tue
figure.

nulla? Avete qualche link che può aiutarmi?
Sempre sul tutorial, dovresti trovare qualche utile spunto da
http://java.sun.com/docs/books/tutorial/2d/display/user.html
(ma anche da altri esempi alle pagine precedenti)
HTH
-- 
Ciao
	Fabrizio C.

figure.
Cosa ti hanno fatto di male le nuove versioni del JDK? :-D
-- 
Ciao
	Fabrizio C.

 Cosa ti hanno fatto di male le nuove versioni del JDK? :-D
Nulla, č che non conoscendoli non posso dargli consigli.
Ma visto che la sua richiesta č perfettamente fattibile anche con il vecchio
Graphics............
:)
Ciao.


Fabrizio C.
Ciao


	Fabrizio C.
Ciao


seconda di alcuni dati che ricevo da un server ogni.....poco tempo ;-)
cosi' ad ochhio io mi creerei un componente apposito... eredita da
JComponent o JButton a seconda delle funzionalita' che necessiti.
poi li crei e li metti in un Box orrizzontale. poi, mediante metodi
che implementerai, permetterai la modifica dell'attributo che indica
la dimensione e forzerai un repaint. nel metodo paintComponent del
componente metterai poi la logica di ridisegno del componente in base
a tale attributo.
il coso che otterrai sara' un bell'oggettino che si ridisegnera'
quando necessario...
cosi' ad occhio... ripeto.
ciao
-- 
Seti@Home Java Applets
http://maruko.cjb.net/

a
tale attributo.
Mica male come idea in effetti.....si vede proprio che
non sono ancora abituato a vedere tutto come un'oggetto  :-/
Grazie


Mi spieghi perché ti crea problema disegnare ogni volta dei rettangoli?
Pensi che fisicamente un oggetto bottone sia tanto differente da un
rettangolo disegnato?
Il metodo paint(..... ) o paintComponent(---------) vengono richiamati ogni
volta che un oggetto ha necessità di essere ridisegnato.
Gli oggetti come i bottoni o come qualunqua altro componente che vedi a
video, se cambiano una qualunque loro proprietà (colore, forma, dimensione,
posizione) invocano il metodo per il ridisegno repaint() che chiama
Update(Graphics g) che se non viene reimplementato si occupa della
cancellazione del contenuto grafico dell'oggetto e poi il paint(graphics g)
o paintComponent(graphics g);
Crati una classe dove metti le proprietà dell'oggetto e poi memorizzi in un
vettore (Vector)  i tuoi oggetti;
es :
public class MySprite
{
    // Come vuole la programmazzione OOP le variabili
    // dovrebbero essere tutte private e accessibili solo mediante
    // opportuni metodi.
    // Le prime 4 variabili le useremo per indicare :
    // punto di origine (x,y) e dimensione (w,h)
    private     int xPos = 0;
    private     int yPos = 0;
    private     int wSize = 100;
    private     int hSize = 100;
    // poi ci sono proprietà come il colore di sfondo e primo piano
    private     Color fore = new Color(0,0,0);
    private     Color back = new Color(200,200,200);
    // e proprietà dedicate al disegno
    // Raised è un parametro della funzione di disegno draw3dRect e
fill3DRect
    // Empty la useremo per scegliere se disegnare un rettangolo pieno e
vuoto.
    private     boolean raised = false;
    private     boolean empty = false;
    // Quando saremo più bravi (io pure vorrei capirci qualcosa di più di
Graphics 2D
    // Aggiungeremo altre proprietà come :
    // angolo di rotazione
    // fattore di scaling
    // modalità di disegno
    // accuratezza
    // trasparenza
    // antialiasing
    // tipo di tratto
    // distorsione
    // filtri
    // etc.
    public int getX(){
        return x;
    }
    public int getY(){
        return y;
    }
    public int getW(){
        return w;
    }
    public int geth(){
        return h;
    }
    public boolean isEmpty(){
        return empty;
    }
    public boolean israised(){
        return raised;
    }
    public void setLocation(int x, y){
        this.x = x;
        this.y = y;
    }
    public void setSize(int w, int h){
        this w = w;
        this h = h;
    }
    // Mettiamoci qualche costruttore
    public MySprite(){}
    public MySprite(int x, int y, int w, int h){
        setLocation(x,y);
        setSize(w,h);
    }
    public MySprite(int x, int y, int w, int h,boolean raised, boolean
empty){
        setLocation(x,y);
        setSize(w,h);
        this.raised = raised;
        this.empty = empty;
    }
}
Nel metodo paint dell tuo Container rigeneri tutte le figure
I video giochi fanno così perchè tipicamente le figure possono andare a
coillidere, quindi la logica per capire quali pixel riscrivere potrebbe
generare logiche più pesanti del semplice ridisegno del pannello.
public void paint(Graphics g)
{
    // faccio finta che tu abbia già inizializzato il vettore con n elementi
    int numSprite = vettore.size();
    for(int idx = 0; idx<numSprite; idx++)
    {
        MySprite sprite = (MySprite)vettore.elementAt(idx);
        if(sprite.isEmpty())
            draw3DRect(sprite.getX(), sprite.getY(), sprite.getW(),
sprite.getH(), sprite.isRaised());
        else
            fill3DRect(sprite.getX(), sprite.getY(), sprite.getW(),
sprite.getH(), sprite.isRaised());
    }
}
E questo è tutto.
Spero di averti dato qualche buona idea........
Ciao

Spero di averti dato qualche buona
idea........
Grazie per la classe, adesso continuo a lavorarci e vedrò
di tirare fuori qualcosa di funzionale ed elegante ;-)
Ciao



per alcune delle cose della lista dai un'occhiata a setRenderingHint,
ad es.:
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
attiva l'antialias...


Graphics............
Esagero: si possono disegnare rettangoli anche solo con carta e penna 
(e anche con meno).
Tutto, rigorosamente, IMHO. ;-)
-- 
Ciao
	Fabrizio C.

pesante?
Mi piacerebbe sapere da dove arriva quest'idea diffusa che i componenti 
per il 2D e/o Swing (se è di questi che stiamo parlando) siano 
_pesanti_. (sul serio)
-- 
Ciao
	Fabrizio C.

cominciare, per cui mi ho ancora qualche "piccola" lacuna
Le "Overview" ci sono apposta :-)
http://java.sun.com/docs/books/tutorial/uiswing/painting/overview.html
Hai già guardato il codice dei demo nella cartella demo del jdk?
Sono un'ottima fonte di soluzioni (sempre IMHO).
-- 
Ciao
	Fabrizio C.

 _pesanti_. (sul serio)
Per quanto mi riguarda ho questa convinzione per 2 motivi: nel JDK si
parla esplicitamente di componenti più leggeri di altri (lightweight), e
inoltre anche solo per il fatto che una classe ne estenda un'altra
implica per forza di cose che occupi più memoria e risorse in genere,
fosse anche per la semplice aggiunta di una piccola proprietà.
Sbaglio? Che poi ci sia poca differenza a proposito di occupazione di
risorse o velocità poi imho è un altro discorso.
Giusto per curiosità, si può trovare (o si può calcolare) da qualche
parte quante risorse occupano delle istanze delle varie classi?
Lis
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Sono un'ottima fonte di soluzioni (sempre IMHO).
A questo non ci avevo mai pensato, gli daro' un occhio, grazie


 Sbaglio?
[cut]
Si, credo che sbagli.
La dicitura lightweight non origina solo dal "peso" in termini di
occupazione di memoria, ma da una serie di fattori che potrai leggere al
link sotto; inoltre i componenti "lightweight" sono proprio gli swing e non
gli awt!
Ti riporto qualcosa da 
http://java.sun.com/products/jfc/tsc/articles/mixing
in cui viene spiegato perchè è meglio usare swing piuttosto che awt:
Heavy and light components
Most of the issues related to mixing AWT and Swing components are related
to the mixing of so-called heavyweight and lightweight components.  A
heavyweight component is one that is associated with its own  native screen
resource (commonly known as a peer). A lightweight component is one that
"borrows" the screen resource of an ancestor  (which means it has no native
resource of its own -- so it's "lighter").
(Lightweight component support was introduced in JDK1.1, and you can  read
more about it in the JDK1.1  Lightweight UI Framework design document.)
We generally don't recommend mixing Swing and AWT components because  there
are significant benefits in sticking with programs that are written
entirely in Swing (and thus use only lightweight components).
Some of the benefits of using Swing components are:
//////////*********************************LEGGI
QUI!!!**************************/////////////////
More efficient use of resources: Lightweight components are  really
"lighter" than heavyweight components.
More consistency across platforms because Swing is written  entirely in
Java.
Cleaner look-and-feel integration: You can give a set of components  a
matching look-and-feel by implementing them using Swing.
//////////******************************************************************
******////////////////
Despite the benefits of using Swing components exclusively, a developer  may
sometimes have to mix AWT components and Swing components in the same
program (even when migration is not to blame). For example, such mixing  may
be required when a Swing version of a particular AWT component is  not yet
available.
Because there's sometimes no alternative to mixing heavyweight and
lightweight  components, we have provided a few options in Swing to make a
certain  level of component-mixing possible. However, as anyone who has
tried this  approach knows, there are some practical limitations to this
approach.
----------------------------------------------------------------------------
----
Heavy vs. light: the differences
There are some significant differences between lightweight and heavyweight
components. And, since all AWT components are heavyweight and all Swing
components are lightweight (except for the top-level ones: JWindow, JFrame,
JDialog, and JApplet), these differences become painfully apparent when  you
start mixing Swing components with AWT components.
The differences boil down to the following:
A lightweight component can have transparent pixels; a heavyweight  is
always opaque.
A lightweight component can appear to be non-rectangular because of  its
ability to set transparent areas; a heavyweight can only be rectangular.
Mouse events on a lightweight component fall through to its parent;  mouse
events on a heavyweight component do not fall through to its parent.
When a lightweight component overlaps a heavyweight component, the
heavyweight component is always on top, regardless of the relative z-order
of the two components

 Si, credo che sbagli.
[cut su spiegazione]
Ho letto anche la pagina che mi hai segnalato e ho capito che avevo
delle convinzioni del tutto errate.
Grazie



g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANT
IALIAS_ON);
Era esattamente quello che volevo suggerirgli, però impostando le proprietà
su un oggetto così da renderlo personalizzato.

posizionarsi su di un'altro, che succede se poi lo rimuovi?
che sparisce e quello sotto si ridisegna. se erediti da JComponent e
simili queste cose ti vengono in omaggio. crei un oggetto al pari di
un bottone o un altro componente.
in ogni caso, se procedi a modo mio, entra in gioco il layout manager
per il posizionamento dei componenti. se vuoi fare sovrapposizioni
devi usare un layout null...
nel suo caso sono rettangoli affiancati orizzontalmente che si
espandono in verticale (un istogramma?). quindi un Box orrizzontale
con dentro i componenti credo sia una buona soluzione.


 con dentro i componenti credo sia una buona soluzione.
No, è una barra orizzontale, ad altezza e larghezza fissa ma con i
rettangolini all'interno che cambiano di larghezza
P.es:
+------------------------------------------------------+
|    |     |  |  |            |       |    |    |    | |
+------------------------------------------------------+
e dopo poco:
+------------------------------------------------------+
|  |   |     |        |    |    |        |    |    |   |
+------------------------------------------------------+
Cmq per il momento ho creato un oggetto ereditandolo da JComponent. E'
venuta una classe semplice e piccolina ma fa esattamente quello che mi
serve. Sinceramente pensavo che fosse più complicato. Grazie per l'aiuto
Ciao


in cui viene spiegato perchč č meglio usare swing piuttosto che awt:
[CUT]
Grazie!
Era proprio quello che intendevo proporre per fare chiarezza su alcune 
"idee diffuse" ed errate, solo che non avevo tempo/voglia di cercare 
riferimenti ufficiali. :-)
Se ti puņ interessare, ti sei appena guadagnato un posto fra i "keep" 
nel mio newsreader :-D
-- 
Ciao
	Fabrizio C.

 nel mio newsreader :-D
Onorato. ;-)
Fausto.