Realizzazione di finestra

belthezor87

il 10 giu 2010, 10:06

43 risposte

43 Risposte - Pagina 3

G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
16 set 2010, 00:40
Mi era venuta in mente una cosa ma forse un po' difficile.
Vorrei aggiungere un easter egg al mio programma in modo che con una combinazione di tasti tipo CTRL-S venga creato un oggetto di una classe che ho implementato, ma questa combinazione deve essere attiva da qualunque punto del prg(da qualunque finestra mi trovi).
spero almeno di essere stato chiaro
Grazie in anticipo
B
blgames
Pochi posts
Iscritto da
mag, 2010
Messaggi:
44
Re: Realizzazione di finestra
16 set 2010, 20:44
Perdonami ma per il momento non ho il tempo di mettermi a scriverti il codice, oggi è relativamente tardi, appena posso ti metto il codice, comunque per fare quello che dici penso basti fare questo:

1) Creati una classe che implementa l'interfaccia per prendere gli input da tastiera (non mi ricordo il nome), mi pare KeyListener;
2) Questa classe va usata per ricevere gli input, quindi qui metti il codice che ti deve mostrare la finestra nascosta;
3) per avviare il codice che mostra il messaggio puoi farti un oggetto (classe) e nel costruttore metti il codice per renderlo visibile, in questo modo quando costruisci l'oggetto già si mette su Visible. Per renderlo invisibile ti basta richiamare il metodo setVisible(false); se l'oggetto eredita da JFrame o simili, dopo che lo metti invisibile puoi fare una cosa del genere: nomeIstanzaClasse = null; (magari l'oggetto sta a livello globale nella classe che prende gli input) in questo modo "ammazzi" l'oggetto e dici al Garbage Collector che può liberare quella memoria.

Quello che ti ho scritto dovrebbe bastarti, vediamo che sai fare, se non ci riesci dimmelo che ti scrivo il codice, consideralo un esercizio
G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
17 set 2010, 19:59
Dopo aver attentamente letto il tuo consiglio ho pensato a un modo leggermente diverso, vediamo se lo condividi e soprattutto se ho capito bene come fare.
Premetto che questo easter egg devo metterlo in un progetto che quindi comprende diverse finestre (una decina).
Creo una classe SINGLETON (che sarebbe il mio easter egg) così si evita di creare diversi oggetti della classe, perchè se l'oggetto è stato creato e quindi è apparsa la finestra relativa non ho bisogno che ripremendo la combinazioni di tasti ne venga creata un'altra.
Fatto ciò non so se ho capito bene la tua spiegazione, cioè
in pratica in OGNI classe (che nel mio progetto è una finestra) io devo "aggiungere" implements KeyListener e nel relativo metodo (ex: keypressed) devo costruire l'oggetto della classe singleton che avrà nel suo costruttore il metodo setvisible e quindi potrò visualizzare la finestra nascosta.
quindi per OGNI e sottolineo OGNI classe io devo avere il metodo keypressed(esempio)?
Non serve che tu mi scriva il codice, anche perche voglio farlo da solo, ma mi servirebbe sapere almeno se il mio ragionamento è giusto

Un'altra cosina....avevo in mente di mettere nella finestra di login/password una jlabel "Tasto maiuscolo attivato" che viene resa visibile solo CAPS LOCK è attivato sulla tastiera.
Ho visto in giro su internet come fare e l'unico metodo che dicono in molti è un'istruzione del tipo
```
if(Toolkit.getDefaultToolkit().getKeyLocked()) 
         Label.setVisible(true)
else Label.setVisible(false)
// non guardare la sintassi perche l'ho scritto ricordandolo a memoria
```
Il problema è che mi da l'errore UnsupportedException..... quindi secondo me è impossibile farlo sotto ubuntu.
Avevo anche visto il metodo usato generalmente per gli altri tasti ma non mi serve che la label viene resa visibile quando premo capslock ma mi serve che deve intercettare l'attivazione di caps lock cioè quando appare la finestra deve gia apparire la label se caps lock è attivato, senza che io prema niente.
In modo dettagliato io ho una jframe con "sopra" un jpanel e sul jpanel i campi di testo jtextfieldusername jpasswordfield password e poi un pulsante ENTRA
Spero di essere stato chiaro e spero di non esagerare con le mie richieste.
Grazie sempre in anticipo
CLA
B
blgames
Pochi posts
Iscritto da
mag, 2010
Messaggi:
44
Re: Realizzazione di finestra
17 set 2010, 22:45
Non hai bisogno di implementare in ogni classe l'interfaccia che ti prende gli input, fatti una classe e per esempio chiamala GestioneInput in questa classe implementi l'interfaccia e quando premi un tasto vengono eseguiti i metodi di quella classe, sempre in questa classe puoi mettere altri metodi che per esempio vedono se è stato premuto Bloc Maiusc tu dici come? guarda questo pezzo di codice:
```
import java.awt.*;
import java.awt.event.*;

public class Test {

    public static void main(String[] args) throws AWTException {
	
        // create AWT component
        Frame f = new Frame();
        // handle component's keyPressed event
        f.addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent ev) {
                System.out.println(Character.isUpperCase(
                  ev.getKeyChar()) ? 
                    "Caps Lock ON" : 
                    "Caps Lock OFF");
            }		
        });
        // make component visible (otherwise the Robot won't work)
        f.show();
        // create Robot
        Robot robot = new Robot();
        // generate simple caracter key press
        robot.keyPress(KeyEvent.VK_A);	
	
    }

}
```
Grazie alla classe Robot riesci a simulare la pressione di un tasto, nell'esempio fa un controllo per vedere se i caratteri sono maiuscoli o minuscoli quindi da li dedurre se BlocMaiusc è attivo, l'altro modo che invece puoi usare è il seguente:

Fai finta di avere un oggetto IstanzaOggetto quindi:
```
IstanzaOggetto.getToolkit().getLockingKeyState( KeyEvent.VK_CAPS_LOCK)
```
Nella classe GestioneInput puoi creare un metodo come questo per sapere se Bloc Maiusc è premuto:
```
public boolean BlocMaiuscPremuto()
{
//non avendo provato il codice non sono sicuro di cosa ritorna il codice seguente se ritorna un boolean non dovresti avere problemi
return this.getToolkit().getLockingKeyState( KeyEvent.VK_CAPS_LOCK);
}
```
nei metodi richiesti dall'interfaccia metti il codice che chiama i metodi di altre classi e magari a queste passi l'oggetto KeyEvent e nei metodi di quelle classi vedi cosa fare con gli input. Però fai in modo che se una finestra non è visibile o non ha lo stato attivo non deve eseguire il codice che gestisce gli input, magari metti un if tipo if(!this.isVisible()){ return;} non mi ricordo se si chiama isVisible il metodo, ritornando al chiamante non esegue il corpo del metodo e quindi non vede gli input

IL codice sopra non l'ho provato quindi non sono sicuro al 100% che funziona però penso che al 90% dovrebbe risolverti i problemi.

P.S.
se sono stato poco chiaro dimmelo che rispiego.
G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
18 set 2010, 15:04
Ho provato entrambi i metodi per il caps lock ma c'è un problema
Nel primo metodo mi compare la mia label "capslock attivato" anche se esso è disattivato e magari sto scrivendo le lettere maiuscole premendo shift (è ovvio dato che la condizione è se il carattere è maiuscolo o meno)

Il secondo metodo l'avevo gia provato ma quando esegue la seconda istruzione delle 3 seguenti:
```
Toolkit b=this.getToolkit();
boolean a=b.getLockingKeyState(KeyEvent.VK_CAPS_LOCK)
return a;
```
mi da il seguente errore
```
Exception in thread "AWT-EventQueue-0" java.lang.UnsupportedOperationException: Toolkit.getLockingKeyState
        at java.awt.Toolkit.getLockingKeyState(Toolkit.java:1386)
```
Per quanto riguarda l'easter egg non ho capito bene .. perche se io implemento il metodo ad es. keypressed in una classe A, i tasti che premo saranno intercettati quando mi trovo su quella classe...e non se sono su altre finestre, no? Per questo ti dicevo che in ogni classe devo mettere il metodo keypressed che magari chiama un metodo della classe A
G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
18 set 2010, 18:38
E anche un'altra cosa

Ho visto che facendo Toolkit t=this.getToolkit() ritorna un oggetto XTolkit invece dovrebbe ritornare un oggetto MToolkit ma non so come fare...ho letto che si deve settare la variabile d'ambiente AWT_TOOLKIT=MToolkit, io l'ho settata in bashrc ma non so se è giusto settarla lì, cmq non funziona lo stesso.

blgames

Pochi posts

Iscritto da: mag, 2010

Messaggi:: 44

Re: Realizzazione di finestra

18 set 2010, 20:14

Per fare prendere gli input da una finestra devi fare attenzione ai componenti che sono messi, perché questi sono focusabili cioè quando premi per esempio su un bottone questo si prende il focus togliendolo alla finestra e quindi non vede più i tasti, poi devi aggiungere l'oggetto che gestisce gli input tramite il metodo addKeyListener della classe che magari ti mostra la finestra, questo va fatto per tutte le classi. Per quanto riguarda il Bloc Maiusc tramite il Toolkit a me funziona benissimo su Windows, ho riutilizzato il codice che avanza il valore della barra fermando l'avanzamento del valore appena premo A e ripartire (continuare dal valore) sempre con A:


/**
 *
 * @author Luigi
 */
public class Main extends JFrame implements ActionListener{

    Container contenitore;
    JButton Bottone;
    Finestra finestra = null;

    private JProgressBar Barra = null;
    private GestisciValoreBarra ValoreBarra = null;
    private GestioneInput Input = null;

    public Main()
        {
            super("prova");
            this.setSize(400, 400);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

            contenitore = this.getContentPane();
            contenitore.setLayout(new FlowLayout());


            Bottone = new JButton("Entra");
            Bottone.setFocusable(false);//METTILO IN TUTTI I COMPONENTI CHE HAI SUL JFRAME
            Bottone.addActionListener(this);

            contenitore.add(Bottone);

            Barra = new JProgressBar(0, 100);
            Barra.setFocusable(false);
            Barra.setPreferredSize(new Dimension(100, 15));

            contenitore.add(Barra);

            finestra = new Finestra("Finestra 2", this.getOwner());
            finestra.setLocation(50, 50);//posiziona la finestra nello schermo
            finestra.setSize(200, 200);
            finestra.setVisible(false);

            ValoreBarra = new GestisciValoreBarra(Barra, contenitore, finestra);

            Input = new GestioneInput(ValoreBarra);

//FAI ATTENZIONE ALLE TRE RIGHE DI CODICE SEGUENTI
            this.addKeyListener(Input);
            this.setFocusable(true);
            this.requestFocus();

            this.setVisible(true);

        }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        new Main();

    }

    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == Bottone)
            {
                ValoreBarra.start();//ATTENZIONE SE VUOI FARE PIU' CONTROLLI PER VEDERE SE IL METODO DELLA CLASSE GESTIONEINPUT (ISTANZA INPUT) DA IL VALORE GIUSTO NASCONDI QUESTA RIGA DI CODICE, CIOE' METTILA COME SE FOSSE COMMENTO

                if(Input.BlocMaiuscAttivo())
                    System.out.println("Bloc Maiusc attivo");
                else
                    System.out.println("Bloc Maiusc non attivo");

            }
    }

public class GestisciValoreBarra extends Thread
        {
            private final int VALORE_INCREMENTO = 2;
            private JProgressBar Barra = null;
            private Container Contenitore = null;
            private int ValoreCorrente = 0;
            private Window Finestra = null;
            private boolean ThreadFermato = false;

            public GestisciValoreBarra(JProgressBar Barra, Container contenitore, Window finestra)
                {
                    this.Barra = Barra;
                    Contenitore = contenitore;
                    Finestra = finestra;
                    Finestra.setVisible(false);
                }

        @Override
            public void run()
                {

                    while(ValoreCorrente < Barra.getMaximum())
                        {
                            ValoreCorrente += VALORE_INCREMENTO;
                            Barra.setValue(ValoreCorrente);
                            Contenitore.repaint();
                            try
                                {
                                    Thread.sleep(100);
                                }
                            catch (InterruptedException ex) {}

                        }

                    Finestra.setVisible(true);
                }

        public void ControllaBarra(KeyEvent e)
            {
                if(e.getKeyCode() == KeyEvent.VK_A)
                    {
                        if(!ThreadFermato)
                            {
                                System.out.println("fermato");
                                ThreadFermato = true;
                                this.suspend();
                            }
                        else
                            {
                                System.out.println("partito");
                                ThreadFermato = false;
                                this.resume();
                            }
                    }
            }
        }

    public class GestioneInput implements KeyListener
        {
            private GestisciValoreBarra ValoreBarra = null;
            public GestioneInput(GestisciValoreBarra VBarra)
                {
                    ValoreBarra = VBarra;
                }
            public void keyTyped(KeyEvent e) {

            }

            public void keyPressed(KeyEvent e) {
                ValoreBarra.ControllaBarra(e);
//QUI PUOI METTERE TUTTI GLI OGGETTI CHE VUOI PASSALI NEL COSTRUTTORE E RICHIAMI I METODI
            }

            public void keyReleased(KeyEvent e) {

            }

            public boolean BlocMaiuscAttivo()
                {
                    return Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK);
                }
        }

}

Codice provato e funzionante su Windows, se hai problemi fatti sentire.

G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
18 set 2010, 20:39
Per quanto riguarda l'easter egg mi viene il forte dubbio che non è la strada giusta quella del keylistener, perche secondo questo metodo io dovrei come ti dicevo avere il metodo key pressed in ogni classe e ogni volta che mi trovo in una finestra che comprende diversi componenenti dovrei associare ogni componente come ascoltatore altrimenti come dici bene se sposto il focus su un componente diverso dalla finestra non funziona piu.
Detto questo io rinuncerei a questa cosa anche perchè era solo una cosa "estetica" e inutile allo scopo del progetto

Per quanto invece riguarda il caps lock io ho copiato e incollato il tuo codice ma nel mio mi da sempre quell'errore che ti dicevo (UnsupportedException) forse perche io uso ubuntu e jdk 6...leggendo un po in giro ho letto che nelle jdk precedenti si usava il Mtoolkit(Motif Toolkit) invece dalla jdk6 viene usato il XToolkit e con questo non posso usare il metodo visto prima getkeyLocking qualcosa...
Quindi anche a questo dovrò rinunciare...

Grazie lo stesso dell'aiuto, ci mancherebbe
B
blgames
Pochi posts
Iscritto da
mag, 2010
Messaggi:
44
Re: Realizzazione di finestra
18 set 2010, 21:23
Se vuoi puoi implementare l'interfaccia in ogni classe che ti serve semplicemente metti tanti metodi tutti uguali nelle varie classi niente di che.
Per il problema del Bloc Maiusc ho trovato un bug però non so se lo hanno risolto ecco il link:

http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4414164

Su Win mi funziona non capisco perché non va

edit: leggi qua è in inglese ha il tuo stesso problema: http://en.allexperts.com/q/Java-1046/2008/10/Toolkit-getDefaultToolkit-getLockingKeyState-error.htm non si può risolvere è un bug della JVM, quello che mi fa piangere e che ancora non lo hanno risolto.
G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
18 set 2010, 21:51
E vabè rinuncerò al tasto maiuscolo...

Per l'easter egg avevo intuito di dover replicare il codice del metodo su tutte le classi..e fin qui va bene ma se l'ascoltatore è la finestra e poi mi sposto sul campo di testo non funziona piu quindi...
G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
25 set 2010, 13:00
Ho bisogno ancora del tuo aiuto,
ho una classe main che chiama la prima finestra (quella di login/passoword) e da lì parte tutto il programma però se avvio piu volte la classe principale compare piu volte la finestra di login(ovviamente)
E' possibile evitare ciò senza usare il pattern singleton?
B
blgames
Pochi posts
Iscritto da
mag, 2010
Messaggi:
44
Re: Realizzazione di finestra
06 ott 2010, 20:48
Perdonami se non ti ho risposto subito ma avrò cancellato la e-mail che mi avvisa quando qualcuno scrive, scusa.
Per tornare IT vuoi creare un applicazione a singola istanza? Cioè se l'applicazione è aperta non si deve aprire un'altra applicazione dello stesso tipo?
G
gvpdip
Pochi posts
Iscritto da
giu, 2010
Messaggi:
24
Re: Realizzazione di finestra
16 ott 2010, 13:57
Non fa niente, tranquillo!!
Sei stato anche troppo disponibile....ti ringrazio....ho appena fatto l'esame e il 30 e lode è anche merito tuo:D
Ci risentiamo presto suppongo....
Grazie ancora di tutto!
B
blgames
Pochi posts
Iscritto da
mag, 2010
Messaggi:
44
Re: Realizzazione di finestra
16 ott 2010, 19:41
Complimenti bravo! Se hai di bisogno devi solo scrivere

Devi accedere o registrarti per scrivere nel forum

43 risposte