liste et tables pouvant être liées groovy swingbuilder

Question

Existe-t-il un moyen de lier des données à une liste et/ou à une table en utilisant la syntaxe de liaison groovy swing builder? Je n'ai pu trouver que des exemples simples qui lient des propriétés simples comme des chaînes et des nombres à un champ de texte, une étiquette ou un texte de bouton.

Answer 1

Had un coup d'œil, et le mieux que je pouvais voir utilisait GlazedLists plutôt que des listes standards Swing

http://www.jroller.com/aalmiray/entry/glazedlists_groovy_not_your_regular

Answer 2

Il y a un GlazedList plugin. Et this article est très utile. Les gars Griffon ne jurent que par GlazedLists.

Answer 3

Je viens de faire quelque chose comme ça - ce n'est vraiment pas si difficile à faire manuellement. C'est toujours un travail en cours, mais si cela aide quelqu'un, je peux donner ce que j'ai. Jusqu'à présent, il lie les données dans les deux sens (la mise à jour des données met à jour le composant, l'édition de la table met à jour les données et envoie une notification à toute propriété ChangeListeners de la "Row"). table. Vous créez cette classe pour définir la nature de votre table. Il ressemble à ceci:

class Row 
{ 
    // allows the table to listen for changes and user code to see when the table is edited 
    @Bindable 
    // The name at the top of the column 
    @PropName("Col 1") 
    String c1 
    @Bindable 
    // In the annotation I set the default editable to "false", here I'll make c2 editable. 
    // This annotation can (and should) be expanded to define more column properties. 
    @PropName(value="Col 2", editable=true) 
    String c2 
} 

Notez qu'une fois que le reste du code est emballé dans une classe, cette classe « rangée » est la seule chose qui doit être créé pour créer une nouvelle table. Vous créez des occurrences de cette classe pour chaque ligne, vous les ajoutez à la table et vous avez terminé - aucune autre interface ne permet de mettre la table dans un cadre.

Cette classe pourrait inclure un peu plus de code - j'ai l'intention de le faire contenir un thread qui interroge une base de données et met à jour les propriétés liées, alors la table devrait ramasser les changements instantanément.

Afin de fournir des propriétés de colonne personnalisée I défini une annotation qui ressemble à ceci (je prévois d'ajouter plus):

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.FIELD) 
public @interface PropName { 
    String value(); 
    boolean editable() default false 
} 

Le reste est une classe qui construit la table. Je le garde dans une classe séparée afin qu'il puisse être réutilisé (en l'instanciant avec une classe "Row" différente)

NOTE: J'ai massacré ceci comme je l'ai collé afin qu'il ne puisse pas fonctionner sans un peu de travail (accolades probablement). J'avais l'habitude d'inclure un cadre que j'ai enlevé pour inclure simplement la table. Vous avez besoin d'envelopper la table de retour getTable() dans un cadre ..

public class AutoTable<T> 
{ 
    SwingBuilder builder // This way external code can access the table 
    def values=[] // holds the "Row" objects 
    PropertyChangeListener listener={repaint()} as PropertyChangeListener 

    def AutoTable(Class<T> clazz) 
    { 
     builder = new SwingBuilder() 
     builder.build{ 
     table(id:'table') { 
      tableModel(id:'tableModel') { 
      clazz.declaredFields.findAll{ 
       it.declaredAnnotations*.annotationType().contains(PropName.class)}.each { 
       def annotation=it.declaredAnnotations.find{it.annotationType()==PropName.class 
       } 
       String n=annotation.value() 
       propertyColumn(header:n, propertyName:it.name, editable:annotation.editable()) 
      } 
      } 
      tableModel.rowsModel.value=values 
     } 
    } 
    // Use this to get the table so it can be inserted into a container 
    def getTable() { 
     return builder.table 
    } 

    def add(T o) { 
     values.add(o) 
     o.addPropertyChangeListener(listener) 
    } 

    def remove(T o) { 
     o.removePropertyChangeListener(listener) 
     values.remove(o) 
    } 

    def repaint() { 
     builder.doLater{ 
      builder.table.repaint(); 
     } 
    } 
} 

Il y a probablement une façon de le faire sans ajouter/supprimer en exposant une liste bindable, mais on avait l'impression plus de travail sans beaucoup de benifit.

À un moment donné, je mettrai probablement la classe finie quelque part - si vous avez lu jusqu'à présent et êtes toujours intéressé, répondez dans un commentaire et je serai sûr de le faire plus tôt que tard.