Newsgroup: it.comp.java
Titolo: Eventi con oggetti sovrapposti

Ciao a Tutti,
Volevo sapere come si puoi far processare un evento da componente parent.
per esempio ho un JPanel che contiane al suo interno 2 JTable ora vorrei 
   che quando clicco su un JTable si ha l'evento click anche sul JPanel 
però con le cordinate x e y rispetto al JPanel e non al JTable.
grazie in anticipo
Danilo

webdel wrote:

Se disponi delle coordinate sul riferimento della JTable, per avere le
coordinate sul riferimento del JPanel basta che sommi alle coordinate della
JTable, la posizione della JTable nel JPanel, ovvero:
Coordinata X:
--------------
Posizione_X_rispetto_JPanel = JTable.getX() + JTable.getMousePosition().x 
Coordinata Y:
--------------
Posizione_Y_rispetto_JPanel = JTable.getY() + JTable.getMousePosition().y 
-- 
Ciao,
 Fabrizio
=== 
http://www.negusweb.it
 ===

grazie,
per quanto riguarda il passaggio dell'evento al JPanel?
Danilo
Negus ha scritto:


 per quanto riguarda il passaggio dell'evento al JPanel?
Dipende ... da come hai strutturato il programma.
Se JPanel e JTable li hai istanziati nella stessa classe, puoi
catturare l'evento implementando l'interfaccia dell'evento nella classe
stessa;
Ti faccio un esempio-guida con un JButton ...
class test implements ActionListener
{
    JPanel p=new JPanel();
    JButton b=new JButton();
    public void actionPerformed(ActionEvent e)
    {
          // Qui il codice per la gestione degli eventi sul JButton
    }
    test()
    {
        b.addActionListener(this);
        p.add(b);
    }
    public static void main(String[] args)
    {
        new test();
    }
}
Se hai "infilato" la JTable in un'altra classe, allora puoi utilizzare
il design pattern "observer".
Se hai problemi, fammi sapere.
Ciao,
    Fabrizio

grazie fabrizio,
ti faccio un esempio con il codice
class testpanel extends JPanel{
	JButton b=new JButton();
	public testpanel(){
		this.add(b);
	}
 
}
ora vorrei che che quando clicco su b vorrei avere l'evento click anche 
per testpanel e vorrei che l'event Object abbia  e.getSource() == 
testpanel e non a b.
cosa è il design pattern "observer"?
ciao e grazie ancora
Danilo
neg...@infinito.it
 ha scritto:


 cosa è il design pattern "observer"?
E' uno stile di progettazione che ti aiuta a risolvere tutti i casi in cui
serve notificare ad un oggetto il cambiamento di stato di un altro oggetto
in cui si è precedentemente registrato.
Supponiamo di avere due oggetti A e B (anche diversi, ovviamente).
Supponiamo che A voglia che, al verificarsi di una certa condizione in B,
venga avviato automaticamente un suo metodo.
Per fare questo, A deve necessariamente lasciare il suo riferimento a B, per
poter poi far richiamare da B il suo metodo predefinito. Per far in modo
che questo metodo sia noto a priori (in modo tale da consentire anche ad
altri oggetti di mettersi in ascolto di B), ovviamente è implementato con
un'interfaccia.
Pensa tutto questo quando ti metti in ascolto di un evento, come ad esempio
quello del JButton.
Che cosa fai?
Quello che fai è:
1) la classe che disporrà del metodo da avviare (la precedente classe A)
dovrà implementare l'interfaccia con dichiara quel metodo (interfaccia
ActionListener ed il metodo da implementare è actionPerformed).
2) devi segnalare al componente la classe dove è presente il metodo da
implementare, ovvero:
// se la classe che contiene il metodo è quella su cui stiamo lavorando.
addActionListener(this);
Tutti i riferimenti che vengono passati come parametro di addActionListener,
vengono inseriti in un vettore che verrà scandito al momento opportuno per
scatenare l'evento prefissato di tutti gli oggetti in ascolto dell'evento;
3) Al verificarsi dell'evento, il componento (l'oggetto, in generale)
avvierà il metodo dell'interfaccia implementato da tutti gli oggetti che si
sono registrati.
Questo è quanto, in breve.
Se fai una ricerca su google, non avrai difficoltà a trovare un mare di
informazioni.


grazie per il tuo tempo,
allora praticamente ho creato un editor di frame con dei componenti miei 
proprietari (extendono componenti swing), l'utente interagiste con i 
componenti tramite javascript e con un editor di eventi. Vorrei che 
l'utente se deve usare l'evento di un mio componente (per esempio 
mousemove) non deve preoccuparsi che magari il componente sia formato da 
   altri comoponenti, ma deve vedere gli eventi come se fossero del 
componente principale.
es:
	class miotextbox extends JPanel{
		JTextField t=new JTextField();
		JButton b=new JButton();
		public miotextbox(){
			this.add(t);
			this.add(b);
		}
 
		.....
	}
ho creato un componente textbox con un pulsante di lato.
Ora l'utente che usa miotextbox non deve sapere che il componente è 
formato da t e da b ma quando per esempio ascolta il mouse listener 
(miotextbox.addMouseListener()) deve funzionare come se fosse un unico 
componente, sia se mi sposto su t che su b mi deve dare che si sta 
spostando su miotextbox con le relative cordinate.
Ho fatto l'esempio di mouse listener ma potrebbero essere altri eventi.
Ciao Danilo
Negus ha scritto:


webdel ha scritto:
 > l'utente se deve usare l'evento di un mio componente (per esempio
 > mousemove) non deve preoccuparsi che magari il componente sia formato da
 >    altri comoponenti, ma deve vedere gli eventi come se fossero del
 > componente principale.
Ovviamente.
 > formato da t e da b ma quando per esempio ascolta il mouse listener
 > (miotextbox.addMouseListener()) deve funzionare come se fosse un unico
 > componente, sia se mi sposto su t che su b mi deve dare che si sta
 > spostando su miotextbox con le relative cordinate.
Quello che la tua classe miotextbox deve fare è:
1) Mettersi in ascolto di tutti gli eventi di interesse e che può 
propagare ad eventuali oggetti che si agganciano a lui;
2) Comunicare il verificarsi di determinati eventi a tutti gli oggetti 
che si sono messi in ascolto.
Ecco un esempio per propagare il click del mouse a tutti gli oggetti che 
usano miotextbox e che si mettono in ascolto dell'evento Action:
----------------------------------------------------
import javax.swing.*;
import java.util.Vector;
import java.awt.event.*;
// La classe text utilizza miotextbox
class textbox implements ActionListener
{
    public void actionPerformed(ActionEvent e)
    {
        System.out.println("Premuto pulsante nel miotextbox!");
    }
    
    public textbox()
    {
        JFrame f=new JFrame("esempio");
        miotextbox mtb=new miotextbox();
        mtb.addAzioniAscoltatori(this);
        f.getContentPane().add(mtb);
        f.setSize(300,300);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);
    }
    
    public static void main(String[] args)
    {
        new textbox();
    }
}
public class miotextbox extends JPanel implements ActionListener
{
    Vector vecAzioniAscoltatori=new Vector();
        // Registro l'oggetto che vuole avere notifica dell'evento Action
    public void addAzioniAscoltatori(ActionListener al)
    {
        vecAzioniAscoltatori.add(al);
    }
        // Ho ricevuto un evento dal pulsante.
        // Oltre a scrivere "premuto pulsante!", comunico l'evento anche 
a             // tutti gli altri oggetti che si erano messi in ascolto
    public void actionPerformed(ActionEvent e)
    {
        ActionListener al;
        System.out.println("premuto pulsante!");
        
        for (int i=0;i<vecAzioniAscoltatori.size();i++)
        {
            al=(ActionListener) vecAzioniAscoltatori.get(i);
            al.actionPerformed(e);
        }
    }
    
    public miotextbox()
    {
        JTextField tf=new JTextField("ciao");
        JButton b=new JButton("ok");
                // Mi metto in ascolto dell'evento Action del pulsante
        b.addActionListener(this);
        add(tf);
        add(b);
    }
}    
Se ci sono problemi, fammi sapere.
Ciao,
     Fabrizio