Volevo mettere sul forum la mia soluzione di un precedente esercizio secondo il modello MVC.
L'esercizio consisteva nel creare un'applicazione che mostrava una finestra contenente tre controlli scorrevoli, un pannello, un pulsante reset e le label opportune, e tre selettori Red, Green, Blue.
Ad ogni momento, a seconda della posizione dei selettori, il pannello mostrava il colore formato dalla combinazione RGB relativa.
Volevo chiedere al forum un consiglio sulle cose che possono essere migliorate nella stesura del programma.
Buongiorno al forum, volevo chiedere gentilmente delucidazioni relativamente al metodo getSize. In particolare, se ho la seguente classe:
public class Rettangolo extends JPanel { Color colore, colore1; Dimension coordinate, coordinate1, area, area1; public void paintComponent (Graphics g) { super.paintComponent(g); g.setColor(colore); g.fillRect(coordinate.width,coordinate.height,area.width,area.height); g.setColor(colore1); g.fillRect(coordinate1.width,coordinate1.height,area1.width,area1.height); } public Rettangolo() { //set the default color of the rectangles Color colore = Color.YELLOW; this.colore = colore; Color colore1 = Color.BLUE; this.colore1 = colore1; //set the default dimension of the rectangles Dimension area = new Dimension(75, 75); this.area = area; Dimension area1 = new Dimension(75, 75); this.area1 = area1; //set the default coordinates of the rectangles Dimension coordinate = new Dimension(0,0); this.coordinate = coordinate; Dimension coordinate1 = new Dimension(250,250); this.coordinate1 = coordinate1; } }
nell'istruzione evidenziata in rosso, come posso impostare coordinate1 utilizzando il metodo getSize() ?
Io ho provato ad eseguirlo sul pannello, ma non ottengo il valore desiderato. E' corretto utilizzare getSize() su un oggetto di tipo JPanel?
Mi sono accorto che setVisible() sul JFrame non prima non è settato a true, mi impedisce di ottenere la dimensione del JPanel.
Ciao, se c'è qualcuno che ha fatto il compito d'esame dell'anno scorso ( quello del bersaglio ) potrebbe mettere sul forum il codice cosi per vedere come lo ha fatto?
1) Cosa fa la "super.clone()" ? 2) A che cosa serve implementare un hashcode ? 3) Da errore se non si implementa un hashcode se implementiamo una equals? 4) Posso implementare due eventi diversi in un file.java? Come? 5) Se voglio per esempio che quando premo un punto su un pannello si disegna un cerchio come faccio ( cioè "mescolare" i components con la paintComponent) ?
1) richiama la clone del padre (risalendo eventualmente fino alla clone di Object che fa una copia bit a bit della memoria occupata dall'oggetto che deve essere clonato)
2) A far funzionare bene le hashtables. Se non è chiaro cosa sono e come funzionano suggerisco i riguardare la parte finale della lezione 18 in video. Dovrebbe valere la proprietà che che due oggetti uguali finiscono nello stesso posto in una hashtable, e due oggetti diversi in posti diversi. Dato che la hashtable usa hashcode per generare la chiave di accesso, quando si cambia la equals si dovrebbe fer in modo che tale proprietà sia valida.
3) No non da errore, ma le hashtables (e le collezioni che mantengono una sola copia di oggetti uguali) potrebbero non funzionare correttamente.
4) Che vuol dire? Non is implementano eventi, ma ascoltatori (gestori) di eventi. Una classe può implementare diverse Listener interfaces, e quindi gestire eventi diversi.
5) Analogo a quanto detto nella risposta data a V.Sartori (paintComponents) di sopra.
Stavo provando un programma semplice in cui si ha nella finestra principale un BorderLayout,dove al centro ho un pannello da gestire,con dei pulsanti posizionati nella parte nord del borderLayout. In questa parte nord ho fatto un'altro JPanel con un flow layout,ho posizionato due bottoni,una label e due textField. Il problema è che i componenti si dispongono tutti in una riga,andando ad uscire dal campo di visuale,non visualizzando ad esempio l'ultimo bottone. ho provato a guardare la documentazione e ho trovato questo:
JFrame frame = new JFrame("FlowLayoutDemo") { public Dimension getMinimumSize() { Dimension prefSize = getPreferredSize(); return new Dimension(100, prefSize.height); } };
cioè va impostata una dimensione minima? ma stando a quanto detto in classe non si arrangiava da solo il Layout Manager a capire quando andare a capo? Il mio problema non è che capita perchè ho posizionato questo pannello a nord di un borderLayout,e quindi viene tutto minimizzato?
oltretutto ho notato che con questo metodo non si fa altro che avere una minima dimensione della finestra,impossibilitando l'utente a rimpicciolirla oltre. In questo caso non c'è un metodo piu veloce,tipo frame.setMinimumSize() ? bisogna sempre fare questo procedimento?
Salve a tutti... Vorrei sapere se qualcuno ha capito come si fa a "togliere" un evento (Actionlistener o Mouselistener) da un oggetto.
Faccio un esempio: dopo aver creato un JButton che chiamo B, gli ho assegnato un Actionlistener (chiamiamolo Al) nel solito modo,
B.addAction_Listener(Al).
Questo fa si che venga attivato un MouseListener (Ml) su un JPanel (jp) che controlla i click del mouse al suo interno.
Adesso volevo fare in modo che premendo nuovamente B (o premendo un nuovo bottone) si disattivasse anche il MouseListener, ma pur facendo
jp.removeMouseListener(Ml)
non cambia assolutamente nulla. C'è qualche altro metodo per ottenere questo risultato o semplicemente sbaglio ad usare il metodo "removeMouseListener"?
Grazie.
Anche qui, aggiungere (IN ATTACHMENT) il sorgente aiuterebbe... Il ragionamento sembra filare, ma vorrei vedere come è implementato per poter rispondere.
do un suggerimento: Se si vuole far si che un bottone aggiunga un punto, e che il pannello mostri tutti i punti creati finora, si può definire una struttura che tenga traccia di quanti punti sono stati finora creati (ad esempio una Collection di Punti). La paintComponent dovrà esaminare la struttura e disegnare tutti i punti in essa presenti. Quando si schiaccia un bottone, questo aggiunge il dato alla struttura e chiama la repaint sul pannello.
Return the current width of this component. This method is preferable to writing component.getBounds().width, or component.getSize().width because it doesn't cause any heap allocations.
Salve a tutti, ho fatto una semplice applicazione contenente due bottoni. La pressione del primo crea altri bottoni ( che si dispongono ordinanatamente secondo il Flowlayout ) mentre la pressione del secondo li cancella ( partendo dall'ultimo creato ).
I problemi sono due:
- Il primo bottone mi crea si il bottone ma si vede soltanto se ingrandisco la finestra, il prof mi ha detto di fare la repaint ma non funziona lo stesso.
-Il secondo bottone non cancella niente....Ho usato una remove..non sò se è giusto...se qualcuno sa come fare vi ringrazio. Ciao
public class Contenuto extends JFrame { JPanel contentPane; JPanel nord = new JPanel(); JPanel centro = new JPanel(); JButton bottone_1 = new JButton("Crea bottone"); JButton bottone_2 = new JButton("Cancella bottone");
public Contenuto() //costruttore della classe che però richiama JbInit... { try { settingJPanel(); //inizializza la finestra } catch(Exception e) { e.printStackTrace(); } } public static void main (String args[]) { new Contenuto(); } }
1) Aggiunta bottoni: nella actionPerformed, dopo p.add(newBotton) occorre chiamare la p.repaint() come avevo suggerito a voce. In realtà tuttavia questo NON BASTA, perchè quando viene modificata la composizione di un Container occorre (prima di farne la repaint) chiamare il metodo validate. Quindi tra la add e la repaint occorre aggiungere una chiamata a p.validate().
2) Rimozione bottoni: varrebbe lo stesso discorso MA QUI C'E' UN ERRORE LOGICO NEL PROGRAMMA. Quello che si intenderebbe fare è RIMUOVERE UNO DEI BOTTONI GIA' PRESENTI, mentre quello che si fa è CREARE UN NUOVO BOTTONE e RIMUOVERLO (senza prima averlo aggiunto...)!. Per fare quel che si desidera, occorrerebbe avere una lista (una collezione, un array, una pila...) in cui tenere traccia dei bottoni già aggiunti ed eliminare l'ultimo!
Ciao a tutti, ho creato una semplice calcolatrice, utilizzabile con mouse o con tastiera. Mi piacerebbe che deste un'occhiata al codice... cosa ne pensate?
Vi allego un archivio jar: con "java -jar Calcolatrice.jar" (oppure con un doppio click) potrete eseguire il programmino. I sorgenti sono nella cartella /src (potrete aprire il jar con WinZip o simili).
Se vi interessa, una semplice guida per creare i jar è la seguente: http://neptune.netcomp.monash.edu.au/JavaHelp/howto/jar.htm
Stavo cercando di creare il programma della seconda prova degli anni passati,e avevo ipotizzato come soluzione,quella di creare nella finestra principale un BorderLayout,all'interno di questo,nella parte nord un'altro pannello con dentro dei componenti. Il problema è che se passo il tutto (la classe MyPanel con dentro il BorderLayout principale) non riesco ad accedere ai componenti piu interni della parte nord. Non trovo la sintassi corretta... Ho chiamato il pannello principale content , il pannello nord north,e non trovo la sintassi,credevo che facendo content.north potessi arrivarci ma non funziona. Come accedere quindi a campi di pannelli contenuti nel BorderLayout?
Ho costruito un pannello regolato da un BorderLayout, a nord ho aggiunt un pannello chiamato north che contiene un bottone chiamato b.
Supponiamo ora che io abbia una classe esterna (ad esempio da un listener) a cui è stato passato il mio MyFrame, e supponiamo che in tale classe il mio MyFrame sia chiamato mf. Se voglio accedere al bottone (ammesso che le regole di visibilità public-private ecc. lo permettano), non devo seguire il contenimento dicendo
mf.content.north.b
ma semplicemente
mf.b
perchè b è una variabile di istanza di MyFrame, e non importa dove graficamente essa sia stata collocata...
Non ho ben capito il problema, cosa significa che devi accedere ai componenti più interni?
Se devi modificare ad esempio qualche jbutton, basta che fai 'nomejbutton'.'azionedesiderata', senza bisogno di accedere a nulla...
Spero di essere stato di aiuto...
Salve a tutti... Ho una domanda: dopo aver impostato il layout come Flow o Border su un JPanel, è ancora
possibile cambiare le dimensioni degli oggetti creati all'interno?
Mi spiego meglio: io creo un JPanel, successivamente imposto un layout ad esempio di tipo Border, dopodichè inserisco una TextArea che chiamo "testo", diciamo in posizione Center nel Layout, a questo punto provo a fare per definirne le dimensioni, ma non cambia nulla...
C'è un modo per ottenere la dimensione dell'oggetto desiderata pur usando tipi predefiniti di Layout?
O devo porre il Layout a null e impostare manualmente il tutto?
Grazie.
Utilizzando un BorderLayout o un FlowLayout non è possibile specificare le dimensioni dei componenti. Sono disponibili altri gestori di layout più flessibili ma meno semplici da utilizzare (ad esempio il GridBagLayout). Tieni presente che anche in questo caso è possibile specificare dei vincoli a cui il componente è soggetto (come per il BorderLayout) che saranno utilizzati per "impaginare" l'interfaccia, e le dimensioni effettive dei componenti saranno calcolate in base a queste e non a quelle esplicitamente specificate da te. Composizioni più complicate si ottengono con il metodo suggerito dal tuo collega, e cioè utilizzando dei pannelli di appoggio sui quali impostare dei gestori di layout opportuni (non null). In generale è buona regola utilizzare questo metodo e non affidarsi al posizionamento assoluto dei componenti.
Io credo che una volta impostato il layout ( a meno che non sia null ovviamente ) non puoi ridimensionare le componenti.....Però hai fatto una domanda interessante....vediamo cosa dicono gli altrivo il prof.
Da quanto ho capito io,il Border layout è quello con i punti cardinali no? Il prof non aveva detto che ad esempio nel CENTER si può mettere un'altro JPanel? perche in tal caso se metti un'altro JPanel li dentro,lo puoi mettere con layout null e puoi inserire ogni cosa dove vuoi,spero di non sbagliarmi....
Non è un problema banale! Per fare una animazione di questo tipo occorre avere DUE threads. Ne discuteremo a lezione più avanti. Per ora dovrà portare un pò di pazienza!
Salve a tutti, ho un piccolo problema.... quando uso un ImageIcon per personalizzare pulsanti e varie non riesco a impostare il percorso relativo. Mi spiego meglio. Se nel path dell'immagine da caricare scrivo il percorso assoluto (C:\\Documents and Settings\\Mauro\\jbproject\\Agenda\\classes\\agenda\\img\\immagine.jpg ) l'immagine viene corretamente caricata e visualizzata. Il fatto di usare un percorso assoluto però non mi piace (per il soolito problema della distribuzione ad altri utenti...). Allora ho provato a inserire il percorso relativo, rispetto alla certella contenente i file class ma le immagini non vengono trovate! i file class si trovano in C:\\Documents and Settings\\Mauro\\jbproject\\Agenda\\classes\\agenda\\
Non so come fare, questa è l'istruzione che dovrebbe caricare l'imamgine e metterla al posto del pulsante:
Se stai usando JBuilder, puoi salvare la tua directory img in quella che per JBuilder e' la "Working Directory" del progetto. Una volta fatto puoi indirizzare l'immagine come hai fatto sopra.
In generale, quando si vogliono distribuire delle risorse associate al programma (come file immagine, gli stessi .class, file di configurazione, ecc..) in modo indipendente dal percorso in cui viene salvata l'applicazione, si puo' "impacchettare" tutto in un archivio con particolari caratteristiche (file .jar). Per approfondimenti si puo' leggere: http://java.sun.com/docs/books/tutorial/deployment/jar/index.html
public void addComponent () { // creazione della label e inserimento nel pannello JLabel l=new JLabel(testolabel+0); l.setSize(200,200); f.getContentPane().add(l);
credo che il tuo problema sia dato dal fatto che fai: f.setVisible(true); prima di aggiungere bottone label ecc... Tu quando crei un Pannello richiami setupGraphicEnvironement e dopo addcomponent. Il problema è che rendi la finestra visibile non appena è creata,e non alla fine di tutto!!dovresti provare a spostare f.setVisible(true); ad esempio nell'ultima riga di addComponent. se non sbaglio non visualizzi i bottoni finche non fai il resize perchè dopo aver reso la finestra visibile non la aggiorni piu,mentre quando fai il resize si aggiorna. Spero sia corretto Comunque sia mancando la classe Listen il programma non funziona correttamente,cioè non vengono contati i click del mouse. ciao ciao
grazie adesso provo e poi ti faccio sapere. comunque la classe listener non l'ho inserita perchè non mi sembrava inerente alla domanda in realtà l'avevo fatta. ciao
Buon giorno a tutti! volevo chiedere a qualcuno il perchè quando creo una finestra con dei componenti all'interno come dei bottoni,label, ecc per riuscirle a visualizzare devo fare un resize della stessa. ciao e grazie a tutti.
Progammando un po' in java a volte sorge la necessità di associare un listener a due oggeti completamente diversi. Si possono adottare molte soluzioni, tra cui creare listener appositi, passare gli oggetti per riferimento, ecc ...
Volendo sfruttare il parametro "e" degli eventi, ho notato che tra i suoi metodi esiste un getClass( ) e getComponent( )..
É possibile sfruttarli per referenziarsi direttamente all'oggetto che è stato cliccato ? e quindi potervi accedere direttamente senza istanziare una nuova classe? (in questo caso eviterei anche import ripetuti in cima alla classe MouseListener ).
In genere si usa chiamare il metodo getSource sull'evento. Questo restituisce l'oggetto per cui l'evento è stato generato. Avendo quindi ad esempio due bottoni collegati allo stesso ActionListener, si può in questo modo disambiguare quale dei due bottoni è stato premuto.
Non è più conveniente formalizzare una classe che non estenda nessuna altra classe grafica? facendo così non ci siamo già sfumati l'opportunità di ereditarietà della classe stessa?
Mi sto riferendo in particolare alle slide del professore in cui, ad ogni esempio il JFrame viene esteso dalla classe esempio che facciamo.
Ci sono dei pro "computazionali" oppure è solo a scopo didattico?
In genere si costruiscono sottoclassi delle componenti grafiche primitive (es. di JFrame) per ottenere componenti customizzate che abbiano i requisiti richiesti per il programma. Nella maggior parte dei casi questo approccio va bene. Responsabilità di tipo diverso (ad esempio gestionali) vengono di solito incapsulate in altre classi che possono essere collegate alla finestra stessa. In genere si segue una scomposizione "Model - View - Controller" in cui il Model contiene i dati, la View la presentazione degli stessi, il Controller tutta la logica di business (ovvero di controllo). La parte "View" può essere fatta sottoclassando classi della libreria grafica.
If you part of the Universit� di Trento community or have posted to a public forum here and received a visitor user account, please log in before posting. If you do not yet have a user account, please register below.
ciao,io credo che il professore abbia utilizzato quel modo per mostrarci una via possibile,ma non l'unica o la migliore,poichè se guardi la documentazione,il primo programma swing è quello del count dei click del mouse,in cui viene implementata la classe ActionListener e non quella JFrame.. da quanto detto fin'ora ereditare una classe ha la maggior parte delle volte lo scopo di utilizare un istanza di quella classe ed aggiungierci funzionalità,ma se devi creare un semplice frame e inserirci bottoni,beh,credo che entrambi i metodi siano corretti,in fondo ActionListener la devi estendere lo stesso no? Questo è quello che penso di aver capito,correggetemi se sbaglio!
Un ciao a tutti, volevo chiedere al forum un consiglio su come poter sviluppare un layout liquido sulla mia semplicissima applicazione: una finestra con un bottone: cliccando sul bottone il bottone si sposta altrove nella finestra. Vi allego anche il mio codice. Come potete vedere, ho inserito il settaggio della dimensione del frame all'interno della classe ButtonPanel, in modo da poter avere le dimensioni della finestra anche nell'actionPerformed , oltre che nel main. Quello che vorrei fare è avere un solo punto in cui settare le dimensioni della finestra (nell'esempio 400 x 300). Come posso fare?
Ciao e grazie anticipatamente per la risposta.
Giampaolo
/** Author: Franco Giampaolo Date: 20 apr 2006 / (Copyright. 2006) - University / Exercise of Prog II When the user clicks the button, it moves to another position. */ import java.util.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*;
class ButtonPanel extends JPanel implements ActionListener { // create the button JButton bottone = new JButton("Click!");
// set the dimension of the window int rangeX = 400; int rangeY = 300;
// constructor : add the button to the ButtonPanel - set size & random position ButtonPanel() { this.add(bottone); this.setLayout(null); bottone.setBounds(rangeX /2 - 50, rangeY /2 - 30, 50, 30); // register the panel as listener at the button bottone.addActionListener(this); bottone.setActionCommand("moving"); }
// this method of ButtonPanel is called when a button is clicked public void actionPerformed(ActionEvent e) { if (e.getActionCommand()=="moving") { int posX, posY; Random generatore = new Random(System.currentTimeMillis()); posX = generatore.nextInt(rangeX - 60); posY = generatore.nextInt(rangeY - 60); System.out.println("The button now in (" + posX + "," + posY + ")"); bottone.setBounds(posX , posY , 50, 30); } } }
public class MoveBottone { public static void main(String[] args) {
JFrame frame = new JFrame("Muovi il bottone"); // creo il bottone nel pannello in posizione (x,y) ButtonPanel panel = new ButtonPanel(); frame.getContentPane().add(panel); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(400, 300); frame.setVisible(true); } }
non capisco bene quello che intendi,ma immagino che vuoi fare una cosa del genere: frame.setSize(DIMENSIONI_IN_BUTTONPANEL) non vorrei dirti una cavolata,ma te li hai inseriti appunto in button panel,giusto? definendoli cosi: int rangeX = 400; int rangeY = 300; quindi non sono private e li dovresti poter richiamare dall'esterno se crei un'istanza di ButtonPanel,cosa che nel main fai quasi subito. Hai provato a fare: frame.setSize(panel.rangeX,panel.rangeY); ? A me funziona senza problemi. Un'altra cosa,ti consiglio di inserire una riga tipo: Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); f.setLocation((screenSize.width - panel.rangeX)/2,(screenSize.height - panel.rangeY)/2);
almeno cosi hai la finestra centrata,è un pò piu bella esteticamente al centro piuttosto che in cima. saluti
Buongiorno a tutti! Secondo voi esiste una priorità particolare nell'inserimento e/o creazione delle componenti grafiche per costruire la GUI all'interno di una classe? Quale sarebbe la priorità per costruire una finestra con un bottone ? Il bottone lo creo prima o dopo aver creato la finestra ? Rendo visibile il JFrame prima o dopo aver creato tutte le componenti ?
Se ho ben capito stai chiedendo in che ordine creare i componenti,giusto? Bene,se quello che ho imparato è corretto,penso che per prima cosa si debba creare un JFrame,in cui verrà posizionato il contentpane,dentro il quale ci puoi inserire i bottoni. Poi dipende da come fai la tua classe,ad esempio nell'esempio precedente la classe estendeva il JFrame,quindi al suo interno si creavano un contentpane e uno o piu bottoni (prima il new ecc... e poi contentpane.add(bottone) ) e l'istanza del JFrame veniva creata o nel main,o in un metodo di appoggio. Per il rendere visibile il tutto,come consigliato dal professore è piu corretto rendere visibile la finestra DOPO aver creato l'intera GUI,altrimenti ti vedi una finestra che si muove,ingrandisce e crea bottoni davanti agli occhi,e non mi pare molto corretto. Spero di aver risposto correttamente e in modo chiaro, in ogni caso ti consiglio di guardare l'esemprio nella documentazione: Vai su Java Tutorials,creating a GUI with JFC/Swing,Learning by example,e segli il secondo esempio. Piu precisamente l'indirizzo è: http://java.sun.com/docs/books/tutorial/uiswing/learn/example2.html Se ti guardi il sourcecode del programma è semplice e ti mostra anche come impostare il look & feel (attento però,ho notato che il GTK su win non è installato). saluti.
La risposta di Dorigatti è sostanzialmente corretta. Ci sono tre fasi nella costruzione di un pezzo di interfaccia: - creazione - inizializzazione-composizione - visualizzazione Suggerisco di rispettare l'ordine delle fasi. PRIMA si creano gli elementi (non importa i che ordine, anche prima un bottone e poi la finestra che lo conterrà). SUCCESSIVAMENTE si inizializzino le componenti specificandone le proprietà (ad es. settando il colore di background, definendo i listeners ecc.). QUINDI s effettui la composizione, pondendo bottoni, labels ecc. nei pannelli (se si prevedono questi contenitori intemedi) e i disponendo i pannelli dentro la finestra. INFINE si visualizzi il tutto.
Questa mattina ero in laboratorio per provare uno dei programmi assegnati dal professore,con un compagno siamo arrivati alla soluzione,ma tale programma non funzionava a dovere. trovate il source qui: http://www.turricatch.altervista.org/SelPosition.java il programma dovrebbe spostare il bottone dove si clicca con il mouse,e se si clicca il bottone quest'ultimo torna alla posizione iniziale. Bene,in laboratorio non funzionava a dovere,cioè spostava il bottone ovunque,ma premendolo non ritornava alla posizione iniziale,lo faceva solo se si trovava nell'area in cui veniva posizionato al momento della creazione. Nel pomeriggio poi ho provato lo stesso file da casa e funzionava alla perfezione,utilizzando Windows. Volevo sapere se qualcuno ha provato qualche programma e ha avuto problemi analoghi.
Ecco in attachmentl file di cui parla Dorigatti. Bravi per essere riusciti a fare una implementazione. Non mi è chiarissimio dalla descrizione quale sia il probleme riscontrato. Devo dire che a prima vista una cosa che sicuramente NON mi piace l'uso delle variabili dichiarate static (anche se questo non ha nulla a che vedere con il problema riferito). In un compito di esame una soluzione basata su static in questo tipo porterebbe ad una sottrazione di punti... Riuscite a riaggiustarlo eliminando lo static usato a spoposito? RIcordate che static si usa quando serve definire una proprietà che deve essere condivisa da tutte le istanze della classe, cosicchè se una la cambia, cambia anche per gli altri. Qui static è usato per risolvere artificiosamente un altro problema. Quale? Qual'è la soluzione corretta?
riguardando il codice mi sono accorto che le righe static int xb e static int yb sono obsolete e non usate. la riga successiva: static Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); viene utilizzata solo in questa riga: f.setLocation((f.screenSize.width - frameSize.width)/2,(f.screenSize.height - frameSize.height)/2); che si trova nel metodo appoggio nella classe,quindi static è inutile,o meglio si può togliere senza danni. D'altro canto,se è vero che stati è usato per proprietà condivise da tutte le istanze di classe,è vero che screenSize è una variabile che dovrebbe essere presa una volta e vale per tutti,poichè solitamente la risoluzione dello schermo è una unica per ogni oggetto. In ogni caso static si può rimuovere,e quindi mi pare che il problema delle variabili static sia passato. Per quanto riguarda il mio problema intendevo dire che,in laboratorio, fintanto che volevo spostare il bottone in base alla posizione del mouse tutto andava perfettamente,ma quando volevo premere il pulsante per farlo tornare alla posizione iniziale,non accadeva nulla,come se tutto fosse coperto da un layer invisibile che gestiva solo il MouseListener. Ora a casa però lo stesso codice funziona,e chiedevo appunto se qualcuno ha riscontrato questa anomalia. Settimana prossima ad ogni modo voglio riprovare il codice.
Ps:Su windows e con Firefox 1.5.0.2 L'RSS non funziona,mi rimanda al sorgente della pagina dicendo: Il file XML specificato apparentemente non ha un foglio di stile associato. L'albero del documento è mostrato di seguito.
