Come testare se un pulsante è stato premuto

[Jamie04]

Se vuoi gestire una "sequenzialità", allora uno "stato" lo devi mantenere per avere memoria di cosa è successo. Poi potrebbero essere flag booleani, contatori o altro .... dipende dalla logica complessiva di questa sequenza.

Il punto semmai è valutare se davvero hai bisogno di una cosa del genere. Non stai forse cercando di complicare "troppo"?

In che senso? In realtà è una cosa molto semplice, è solo una maschera di inserimento/modifica dati in un database. Lo scopo che vorrei ottenere è che il metodo 'salva' sappia se deve lanciare un update sui dati (perché l'utente ha premuto il tasto di modifica) oppure deve lanciare un insert (perché l'utente ha premuto il tasto per inserire un nuovo elemento).
Certo potrei mettere un pulsante "Salva modifica" anziché usare un "Salva" generico, questo forse semplificherebbe il codice....e non è detto che non lo faccia Però volevo evitare di inserire troppi pulsanti anche per non dover gestire tremila setEnabled(true/false) in giro per il codice!

Uhm, deduco che hai ancora da comprendere un po' di cose sui listener. Potrei descrivere un po' di cose ma in questo momento non ho molto tempo ..... sono riuscito a ripescare ora un mio vecchio post: http://forum.html.it/forum/showthrea...1#post13483980

Grazie, ci darò uno sguardo, sempre gentilissimo

[Jamie04]

Allora, ho risolto parzialmente la faccenda modificando così il metodo:

private void bSaveMenuActionPerformed(java.awt.event.ActionEvent evt) {                                          
        if (bNewMenuIsPressed==true) { //se ho premuto nuovo menu salvo un nuovo menu
            Menu newMenu = new Menu();
            newMenu.setMenuName(menuName.getText());
            int result = DBConnection.insertMenu(newMenu);
        //se l'inserimento è andato a buon fine abilito i campi per le altre operazioni
            //e ricarico la lista menu
            if (result == 1) {
                reloadMenuList();
                newMenuIsSaved = true; // per abilitare l'inserimento del prodotto su menu appena inserito
                menuList.setEnabled(true);
                bFindProduct.setEnabled(true);
                bNewMenuIsPressed = false; //rimetto a false il boolean che testa se nuovo menu è stato premuto
            }
        } else if (bNewMenuIsPressed==false){ //se non ho premuto nuovo menu chiamo il metodo che aggiorna
            Menu selectedMenu = (Menu) menuList.getSelectedValue();
            selectedMenu.setMenuName(menuName.getText());
            int result = DBConnection.updateMenu(selectedMenu);
        //se l'inserimento è andato a buon fine abilito i campi per le altre operazioni
            //e ricarico la lista menu
            if (result == 1) {
                reloadMenuList();
                menuList.setEnabled(true);
                bFindProduct.setEnabled(true);
                menuName.setEnabled(false);
                bSaveMenu.setEnabled(false);
                bCancelMenu.setEnabled(false);
                bNewMenuIsPressed = false; //rimetto a false il boolean che testa se nuovo menu è stato premuto
            }
        }
    }

Funziona, ma purtroppo come sempre si è creato un nuovo problema. Se salvo il menu devo (per altri motivi) ricaricare menuList, per cui se rimango sul menu appena salvato la modifica non va più, mi dà una NPE (giustamente) perché la lista è stata ricaricata e quindi non c'è più un elemento correntemente selezionato (infatti NPE punta a selectedMenu.setMenuName(menuName.getText()).
Come posso ovviare a questo problema?

[Jamie04]

La faccio più semplice: esiste un modo per evitare che venga 'perduta' la selezione sulla Jlist facendo in modo che si modifichi solo ed esclusivamente se l'utente ha cliccato su un altro elemento della jlist?

[andbin]

La faccio più semplice: esiste un modo per evitare che venga 'perduta' la selezione sulla Jlist facendo in modo che si modifichi solo ed esclusivamente se l'utente ha cliccato su un altro elemento della jlist?

Anche io la faccio semplice: se rimuovi tutti gli elementi o comunque se rimuovi anche solo quello/i selezionato/i, la selezione (i selectedIndex/selectedIndices e selectedValue/selectedValues) per forza di cose la "perdi".

[Jamie04]

E non c'è modo di salvare da qualche parte la selezione corrente? Un qualche stratagemma per ovviare a questa cosa? Altrimenti devo cambiare completamente implementazione

[andbin]

E non c'è modo di salvare da qualche parte la selezione corrente? Un qualche stratagemma per ovviare a questa cosa? Altrimenti devo cambiare completamente implementazione

Facciamo innanzitutto una premessa: il ListSelectionModel ovvero l'oggetto che gestisce la selezione "ragiona" solo in termini di indici selezionati (singolo, intervallo singolo o intervallo multiplo). Non "sa" nulla dei valori selezionati.
Il fatto che JList abbia getSelectedValue()/getSelectedValues() è solo come "utilità". Questi metodi prendono rispettivamente il primo indice selezionato o gli N indici selezionati, prendono i valori a tali indici e ti forniscono il valore o i valori belli pronti.
E nota: da Java 7 il getSelectedValues() è deprecato in favore di getSelectedValuesList() che restituisce un List<E> invece che un misero Object[].
JList ha anche un setSelectedValue che però rimpiazza la selezione selezionando solo quello. Non è "additivo", insomma.

Ora il punto è: se rimuovi tutti gli elementi e ne inserisci altri (es. caso tipico fai una nuova query su DB per aggiornare la lista di dati), non è detto che tutti gli elementi selezionati prima ci siano ancora nella nuova lista. E se anche ci sono (tutti o solo alcuni), potrebbero pure aver cambiato di posizione. Quindi cosa vuoi fare? Cercare di selezionare "al meglio che puoi" i valori che puoi ancora trovare tra quelli che prima erano selezionati?
Si può fare ma non c'è un metodo apposito/unico già fatto .... ci vuole un pochino di codice da scrivere.

E poi per far corrispondere gli elementi, la uguaglianza è in che termini? In termini di equals() ? Se sì, fai così:
- prendi la lista dei valori selezionati, getSelectedValues() o da Java 7 getSelectedValuesList() e li metti da parte.
- aggiorni interamente la lista (qui presuppongo un remove prima di tutti gli elementi).
- metti gli elementi prima selezionati in un HashSet (si presuppone che i valori abbiano equals/hashCode appropriati).
- scansioni la nuova lista indice per indice. Se un valore lo trovi nel HashSet, allora è da selezionare e quindi usi addSelectionInterval (di JList o del ListSelectionModel) per aggiungere in modo "additivo" la selezione di quel indice.

[Jamie04]

Mmm mi sembra più complicato di quel che io posso gestire, più che altro perché sto anche finendo il tempo a disposizione
Il problema si pone solo se inserisco un nuovo menu e poi voglio modificarlo. Ho pensato e se potessi "legare" in qualche modo il fatto che nel campo di testo c'è una scritta che mi mostra il nome di un menu, segno che sto in fase 'attiva' su quel menu?
Per l'eliminazione non ci sono problemi perché una volta eliminato un menu perdi la selezione e sei costretto a selezionare qualcos'altro, ad ogni modo sono operazioni davvero rare (senza contare che questo è solo un progetto per passare un esame mica un programma che dovrà usare qualcuno ).
Ma penso che faccio di gran lunga prima ad abilitare il pulsante della modifica solo quando c'è un menu effettivamente selezionato. Dopotutto queste operazioni sono rarissime.
Grazie in ogni caso!

[andbin]

Mmm mi sembra più complicato di quel che io posso gestire

Magari non ti servirà .... ma ti mostro come si potrebbe fare come intendevo io. E come vedrai sono davvero poche righe!

Basta fare un semplice metodo come questo:

public static void selectValues(JList jlist, Object[] selectedValues) {
    HashSet<Object> set = new HashSet<Object>(Arrays.asList(selectedValues));
    ListModel listModel = jlist.getModel();

    for (int i = 0; i < listModel.getSize(); i++) {
        Object elem = listModel.getElementAt(i);

        if (elem != null && set.contains(elem)) {
            jlist.addSelectionInterval(i, i);
        }
    }
}

L'obiettivo del metodo è di cercare nel nuovo contenuto di JList gli elementi che prima erano selezionati, se li trova li seleziona. Se si vuole usare getSelectedValuesList() da Java 7 e parametrizzare anche JList/ListModel, si risparmia pure qualcosina come codice.

Poi nel tuo codice:

Object[] selectedValues = jlist.getSelectedValues();
// rimozione di tutti gli elementi, caricamento nuovi dati
selectValues(jlist, selectedValues);

[Jamie04]

Magari non ti servirà .... ma ti mostro come si potrebbe fare come intendevo io. E come vedrai sono davvero poche righe!

Basta fare un semplice metodo come questo:

public static void selectValues(JList jlist, Object[] selectedValues) {
    HashSet<Object> set = new HashSet<Object>(Arrays.asList(selectedValues));
    ListModel listModel = jlist.getModel();

    for (int i = 0; i < listModel.getSize(); i++) {
        Object elem = listModel.getElementAt(i);

        if (elem != null && set.contains(elem)) {
            jlist.addSelectionInterval(i, i);
        }
    }
}

L'obiettivo del metodo è di cercare nel nuovo contenuto di JList gli elementi che prima erano selezionati, se li trova li seleziona. Se si vuole usare getSelectedValuesList() da Java 7 e parametrizzare anche JList/ListModel, si risparmia pure qualcosina come codice.

Poi nel tuo codice:

Object[] selectedValues = jlist.getSelectedValues();
// rimozione di tutti gli elementi, caricamento nuovi dati
selectValues(jlist, selectedValues);

Ma dove dovrei inserire o meglio chiamare il metodo selectValues ?
Non conosco gli hashset... e questa riga è per me piuttosto misteriosa:
HashSet<Object> set = new HashSet<Object>(Arrays.asList(selectedValues));
Comunque grazie, sei sempre gentilissimo!

[andbin]

Ma dove dovrei inserire o meglio chiamare il metodo selectValues ?

Ok .. forse l'ultimo pezzetto di codice non era troppo esplicito, lo ripeto qui:

// 1) Prende i "vecchi" valori selezionati
Object[] selectedValues = jlist.getSelectedValues();

// 2) eliminazione di tutti gli elementi nel jlist e caricamento di nuovi dati
//  .... eliminazione + caricamento ....

// 3) Selezione dei "vecchi" valori (per quelli ancora esistenti) nel nuovo contenuto
selectValues(jlist, selectedValues);

La sequenza logica è quella.

Non conosco gli hashset... e questa riga è per me piuttosto misteriosa:
HashSet<Object> set = new HashSet<Object>(Arrays.asList(selectedValues));

Un "Set" è semplicemente un insieme di valori che non ammette duplicati e che, di base, non definisce alcun ordine/sequenza particolare (certe implementazioni di Set possono definire un qualche ordine). HashSet è una implementazione basata su hash-table (usa quindi hashCode() degli oggetti) e pertanto è "veloce" nel cercare gli oggetti.

Il mio metodo selectValues riceve un Object[]. Nessuno dei costruttori di HashSet è in grado di ricevere un Object[] o comunque un array, però uno dei costruttori è HashSet(Collection<? extends E> c) e quindi può ricevere una "collezione". Tramite asList l'array viene incapsulato in un List ... e List è un Collection. Quindi HashSet viene popolato, indirettamente, con i valori nel Object[].