Discussion :

[pingoui]

Bonjour,

J'essaie d'utiliser le pattern MVC pour mon appli mais je commence sérieusement à me perdre.

Mon appli RCP est composée d'une View avec un TreeViewer.
Mon treeViewer est composé de plusieurs noeuds.

Continent
------------> Pays
-------------------> Région
----------------------------->Ville

Mes objets du domain, sont des POJO

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
package org.pegase.domain;
 
/**
 * La zone continent contenant les différents pays
 */
 
@Entity
@Table(name = "T_CONTINENT")
public class Continent implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "continent_id")
    private long zoneId;// Identifiant du continent
 
    @Version
    private int version;
 
    @Column(name = "continent_name")
    private String continentName;// Nom du continent
 
    @OneToMany(mappedBy = "zone", cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH  })
    private Set<Pays> countries = new HashSet<Pays>();
 
    public Continent() {
    }
 
    public Continent(String continentName) {
        super();
        this.continentName = continentName;
    }
 
/***************** GETTER ET SETTER***************/
 
 
    public void addPays(Pays pays) {
        // le pays est ajouté dans la collection des pays du continent
        countries.add(pays);
        // le poste change de continent
        countries.setContinent(this);
    }
 
    public void deletePays(Pays pays) {
        // le pays est supprimé dans la collection des pays du continent
        countries.remove(pays);
    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
package org.pegase.domain;
 
/**
 * Le pays contenant les différente régions
 */
@Entity
@Table(name = "T_PAYS")
public class Pays implements Serializable{
    private static final long serialVersionUID = 1L;
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "pays_id")
    private long paysId;// Identifiant du pays
 
    @Version
    private int version;
 
    @Column(name = "pays_name")
    private String paysName;// Nom du pays
 
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name = "continent_id", nullable = false)
    private Continent continent;//le continent parent du pays
 
 
    @OneToMany(mappedBy = "pays", cascade = {  CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH })
    private Set<Region> regions = new HashSet<Region>();//La collection de région
 
 
    public Pays() {
    }
 
    public Pays(String paysName) {
        super();
        this.paysName = paysName;
    }
 
 
     */
    public void addRegion(Region region) {
        // la région est ajoutée dans la collection des régions du pays
        regions.add(region);
        // la région change de pays
        region.setPays(this);
    }
 
    public void deleteRegion(Region region) {
        // la région est supprimée dans la collection des régions du pays
        regions.remove(région);
    }           
}

J'utilise des bundles OSGI et Spring DM pour séparer mes différentes couches (ui,service,domain,dao).
J'utilise JPA et EclipseLink pour la persistance et je fais aussi du lazy loadindg avec springweawer.

Avec tout ça, je ne sais comment faire pour que mon treeViewer écoute mes objets du domain.

La vue

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
package org.pegase.ui.views;
 
/**
 * Vue contenant l'explorateur des continents
 */
public class ContinentExplorerTreeView extends ViewPart {
 
    private UIController uiController;
    private TreeViewer treeViewer;
 
    @Override
    public void createPartControl(Composite parent) {
        //Enregistrement de la vue dans le controlleur
        uiController.getUi().setContinentExplorerTreeView(this);
        //création de l'arbre
        this.treeViewer = new TreeViewer(parent, SWT.FULL_SELECTION | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
        this.treeViewer.setContentProvider(new ContinentExplorerTreeContentProvider());
        //Application du rendu
        this.treeViewer.setLabelProvider(new ZoneExplorerTreeLabelProvider());
        //Application du provider de selection
        getSite().setSelectionProvider(treeViewer);
        //Insertion des données dans le TreeViewer
        try {
            treeViewer.setInput(uiController.getServices().getContienentService().findAllContinent());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    @Override
    public void setFocus() {
        treeViewer.getControl().setFocus();// Passage du focus à l'arbre
    }
 
 
    public UIController getUiController() {
        return uiController;
    }
 
    public void setUiController(UIController uiController) {
        this.uiController = uiController;
    }
 
    public TreeViewer getViewer() {
        return this.treeViewer;
    }
}

Le Provider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
public class ZoneExplorerTreeContentProvider implements ITreeContentProvider, PropertyChangeListener {
 
    @Override
    public Object[] getChildren(Object parentElement) {
        // si le parent est un continent, l'enfant est un pays
        if (parentElement instanceof Continent) {
            return ((Continent)parentElement).getPays().toArray();
        // si le parent est un pays, l'enfant est une région
        } else if (parentElement instanceof Pays) {
            return ((Pays)parentElement).getRegions().toArray();
        } else if (parentElement instanceof Region) {
            return ((Region)parentElement).getVilles().toArray();
        } else {
            return null;
        }
    }
 
    @Override
    public Object getParent(Object element) {
        // si l'enfant est un pays, le parent est le continent
        if (element instanceof Pays) {
            return ((Pays)element).getContinent();
        // si l'enfant est une Region, le parent est un pays
        } else if(element instanceof Region){
            return ((Region)element).getPays();
        // si l'enfant est une ville, le parent est une région
        } else if(element instanceof Ville){
            return ((Ville)element).getRegion();
        } else{
            return null;
        }
    }
 
    @Override
    public boolean hasChildren(Object element) {
        return !(element instanceof Ville);
    }
 
    @Override
    @SuppressWarnings("unchecked")
    public Object[] getElements(Object inputElement) {
        return (( List<Continent>)inputElement ).toArray();
    }
 
    @Override
    public void dispose() {        
    }
 
    @Override
    public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {    
    }
    @Override
    public void propertyChange(PropertyChangeEvent evt) {        
    }

Service pour les continents et les pays

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
package org.pegase.services.impl;
 
@Transactional(readOnly=true)
public class ContinentServiceImpl implements IContinentService {
 
    private IContinentDao continentDao;
 
    @Transactional(readOnly=false)
    public void addContinent(Continent continent) {
        continentDao.addZone(zone);
    }
 
    public List<Contienent> findAllContinent() {
        return continentDao.findAllContinent();
    }
 
/*****/
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
package org.pegase.services.impl;
 
@Transactional(readOnly=true)
public class PaysServiceImpl implements IPaysService {
 
    private IPaysDao paysDao;
 
    @Transactional(readOnly=false)
    public void addPays(Pays pays) {
                // on enregistre le pays
        paysDao.addStation(pays);
                //Ajout du pays au continent
                Continent conti = pays.getContinent();
                conti.addPays(pays);
    }
 
    public List<Pays> findAllPays() {
        return paysDao.findAllPays();
    }
 
 
/*****Autres méthodes******/
 
}

Je souhaites écouter les changements sur un objet du domain pour que la vue se rafraichisse.

1) Comment ajouter les listeners aux objets ? Dans le Content Provider ?
2) N'est t'il pas plus propre d'utiliser le DataBinding de JFace que des listeners ?
3)Si oui, je suis un peu perdu sur son fonctionnement. Je ne sais comment l'utiliser Et encore moins dans un TreeViewer.

Le peu de documentation et mon faible niveau d'anglais ne m'aide pas à sortir du brouillard.

D'avance, merci de vos éclaircissement et conseils.

[Gueritarish]

Salut,

Alors, tu peux jeter un oeil sur le billet sur les bindings implémenté par Azerr sur son blog.
Sinon, une idée intéressante est l'implémentation du design pattern Observable/Observer (c'est l'idée derrière le data bindings de JFace).
Tu as un classe Observable et des Observers qui vont être informé des changements que la classe Observable va subir.

Voilà pour les idées à+
Gueritarish

[pingoui]

Salut Gueritarish,

Oui j'ai regardé le blog d'Azerr mais je ne sais comment l'utiliser dans mon treeViewer

Pour écouter mes changements de mes POJO, je voulais utiliser PropertyChangeListener.

Vaut'il mieux utiliser Observer/Observable que PropertyChangeListener ?

Par contre, je ne sais comment ma vue s'enregistre auprès des mes objets en tant que listener. Sachant que les données affichés dans mon arbre proviennent d'une BdD.

Vu que j'ai beaucoup de données dans la base le DataBinding n'est pas plus approprié ?

Merci beaucoup

[Gueritarish]

Salut,

Alors quand tu parles de PropertyChangeListener, j'imagine que tu parles de la classe du package java.beans. Et que tu fais surement référence à cet article sur PojoBindable.
Je dois avouer que je n'ai jamais testé.
Sinon, pour ce qui est du pattern Observable/Observers, comme implémentation, j'aurais plus vu:
-> ton Controller hérite de Observable, comme ça à chaque demande de changement de modèle, si elle s'est bien terminée, tu notifies les Observers.
-> ta vue implémente Observer, comme ça à chaque fois qu'elle reçoit une notification de l'Observable, elle se met à jour.

Pour ce qui est du retour d'expérience sur DataBinding et PropertyChangeListener, t'es plutôt mal tombé avec moi

Voilà, à+
Gueritarish

[pingoui]

Oui je parle bien de la classe java.beans.PropertyChangeListener

Je n'avais pas envisagé de mettre un listener sur un controller et je n'avais pas encore vue ce type de conception mais je trouve ce concept intéressant....

Pour ce qui est du retour d'expérience sur DataBinding et PropertyChangeListener, t'es plutôt mal tombé avec moi

Pas de soucis.... j'aurai peu être la chance d'avoir des éclaircissements par d'autres membres.

Merci pour ton aide
Pingoui

[Gueritarish]

Hum... après, c'est un avis personnel
Si ça trouve tout le monde me jetterait des pierres et me traiterait d'hérétique pour oser faire ça

Mais bon, si on devait toujours suivre ce que fait tout le monde... Y aurait jamais d'innovation
Attention, je dis pas que ma façon de faire est une innovation

[pingoui]

Merci Gueritarish

Y a t'il quelqu'un qui connais JFace Data Binding et qui peut m'orienter. Le peu de doc que j'ai récolté ne m'aide pas à la compréhension

D'avance merci

[azerr]

Bonjour pingoui,

Je croies que tu t'es inspire de mes billets sur Conception d’un client Eclipse RCP et serveur OSGI avec Spring DM et c'est vrai que la partie JFace Databinding je ne l'ai pas traité. Faute de temps -(

Pour ton probleme de binding, je pense qu'il faut vraiment utiliser JFace Databinding pour gerer le binding entre widget et domain. Par contre je pense que ca me parait ambitieux de vouloir gerer le binding avec un treeview sans avoir gerer des binding simples (binding entre une widget Text et une propriete d'un POJO par exemple).

Je ne sais pas si tu as saisi le concept de binding mais ce qui'il faut comprendre ce que tu peux :

* avoir le binding que dans un sens Widget ->Domain, autrement dit quand la widget change ca modifie le domain (mais pas l'inverse)
* binding dans les sens Widget <->Domain . C'est pareil que le premier cas excepte que si tu changes le modele ca change la widget.

Le mecanisme de binding fonctionne en observant le changement de propriete de la widget (en branchant des listeners SWT). Si le binding doit s'effectuer dans les 2 sens il faut que le Domain puisse aussi etre observe, autrement dit pouvoir brancher des listener dessus (en branchant des listeners PropertyChangeListener). Donc si le binding dans un sens te suffit tu n'as pas besoin de gerer des listener au niveau des objets Domain.

Generalement on souhaite gerer le binding dans les 2 sens et pour cela il faut que les objets Domain gère des listeners pour observer le changement de propriete :

* si ton Domain utilise EMF la tu n'as pas de problème puisque le code genere gère ces listeners. Il existe de plus EMF JFace Databinding.

* si ton Domain sont des POJO il faut coder toi meme les listeners et lancer un evenement des qu'un set* est appele. Ce qui peut devenirt fastidieux a coder, c'est pour cela que j'avais créé Pojo Bindable qui permet de transformer le bytecode a la volee des Class (appele Weaving) pour ajouter ces listeners.

Tu utilises Springweaver (la version de Martin Lippert que j'ai patche je croies) qui se base sur Equinox Aspects (pour gerer le weaving). Pojo Bindable peut se baser sur Equinox Aspects donc peut etre que ca peut t'etre util? Maintenant je ne l'ai jamais teste avec JPA/EclipseLink en meme temps (si jamais tu l'utilises je suis tres interesse de ton retour).

Je pense que tu as du le trouver mais je te conseille de lire le tutorial http://www.vogella.de/articles/Eclip...g/article.html

Pour le binding avec un treeview http://tomsondev.bestsolution.at/200...%80%93-part-3/ ca marche avec EMF qui utilise ObservableListTreeContentProvider (je croies que c'est ca qu'il faut utiliser).

Enfin (j'en parlerais dans un prochain post) je suis en train de developper un support Spring pour XWT. XWT est l'un des solution declarative des UI de Eclipse E4. EN gros on peut declarer ses interfaces en XML mais on peut declarer aussi son binding (qui est base sur JFace Databinding). On peut associer une classe Java (appellé CLR, qui permet de gerer les evenements des widgets declares). Le support Spring permettra d'utiliser des bean Spring pour ces classes Java et on pourra beneficier de Spring DM.

Peut etre que ca peut t'interesser?

Je ferais un autre post la dessus quand j'aurrais bien finaliser le support Spring pour XWT (je pense la semaine prochaine).

Bon courage

Angelo

[pingoui]

Salut Angelo
Merci pour tes explications et conseils.

J'attends avec impatience tes nouveaux billets
S'ils sont aussi bien rédigés que les précédents, je vais me régaler !

* si ton Domain utilise EMF la tu n'as pas de problème puisque le code genere gère ces listeners. Il existe de plus EMF JFace Databinding.

Pour EMF, je n'ai pas bien saisi les avantages ce qui n'arrange pas mes affaires...

Pour le binding avec un treeview http://tomsondev.bestsolution.at/200...%80%93-part-3/ ca marche avec EMF qui utilise ObservableListTreeContentProvider (je croies que c'est ca qu'il faut utiliser).

Effectivement, ça a l'air de coller à mon projet mais il faut que je travaille déjà sur EMF et sur le Databinding .... Je ne voit plus la sortie du tunnel
Beaucoup de concepts à digérer pour quelqu'un qui n'est pas du métier


Bref je suis toujours perdu.... voir encore plus.
Je me pose toujours les même questions

Je souhaites écouter les changements sur un objet du domain pour que la vue se rafraichisse.

1) Comment ajouter les listeners aux objets ? Dans le Content Provider ?
2) N'est t'il pas plus propre d'utiliser le DataBinding de JFace que des listeners ?
3)Si oui, je suis un peu perdu sur son fonctionnement. Je ne sais comment l'utiliser Et encore moins dans un TreeViewer.

Je me demande si je ne vais pas simplement utiliser des listeners sur mes objets mais je n'arrive pas mesurer les conséquences de ce type de conception notamment avec beaucoup d'objet à gérer.

Le pingouin paumé

[pingoui]

Bonjour,

j'ai commencé a regarder JFace DataBinding et c'est difficile de trouver des tutos sans utiliser le framework EMF.

Pour le moment, j'ai créer une classe abstraite que tous mes POJO extends par la suite j'utilserai POJO Bindable ;-)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
public abstract class AbstractModelObject {
 
	private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(
			this);
 
	public void addPropertyChangeListener(PropertyChangeListener listener) {
		propertyChangeSupport.addPropertyChangeListener(listener);
	}
 
	public void addPropertyChangeListener(String propertyName,
			PropertyChangeListener listener) {
		propertyChangeSupport.addPropertyChangeListener(propertyName,
				listener);
	}
 
	public void removePropertyChangeListener(PropertyChangeListener listener) {
		propertyChangeSupport.removePropertyChangeListener(listener);
	}
 
	public void removePropertyChangeListener(String propertyName,
			PropertyChangeListener listener) {
		propertyChangeSupport.removePropertyChangeListener(propertyName,
				listener);
	}
 
	protected void firePropertyChange(String propertyName, Object oldValue,
			Object newValue) {
		propertyChangeSupport.firePropertyChange(propertyName, oldValue,
				newValue);
	}
}

Dans mon viewer, j'ai une méthode de création de mon arbre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
	private void createDataBindingTreeViewer (Composite parent) {
		// création de l'arbre représentant l'explorateur des continents
		this.treeViewer = new TreeViewer(parent, SWT.FULL_SELECTION | SWT.MULTI
				| SWT.H_SCROLL | SWT.V_SCROLL);
 
		ObservableListTreeContentProvider cp = new ObservableListTreeContentProvider(
				new TreeFactoryImpl(), new TreeStructureAdvisorImpl());
 
		// Application du modéle de données
		this.treeViewer.setContentProvider(cp);
 
		// Application du rendu
		this.treeViewer.setLabelProvider(new ZoneExplorerTreeLabelProvider());
		// Application du provider de selection
		getSite().setSelectionProvider(treeViewer);
 
		// Insertion des données dans le TreeViewer
		try {
			treeViewer.setInput(uiController.getServices().getContinentService()
					.findAllContinent());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
public class TreeFactoryImpl implements IObservableFactory{
 
	@Override
	public IObservable createObservable(Object target) {
	    if (target instanceof IObservableList)
	    {
	      return (IObservable)target;
	    }
	    else if (target instanceof Continent)
	    {
	    	//TODO
 
	    }
	    else if (target instanceof Pays)
	    {
	    	//TODO
	    	//return BeanProperties.list("pays").observe(target);
 
	    }
	    else if (target instanceof Region)
	    {
	    	//TODO
 
	    }
	    else if (target instanceof Ville)
	    {
	    	//TODO
	    }
 
	    return null;	   
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
public class TreeStructureAdvisorImpl extends TreeStructureAdvisor{
 
	/* (non-Javadoc)
	 * @see org.eclipse.jface.databinding.viewers.TreeStructureAdvisor#getParent(java.lang.Object)
	 */
	@Override
	public Object getParent(Object element) {
		// si l'enfant est un poste, le parent est la zone
		if (element instanceof Station) {
			return ((Station)element).getZone();
		// si l'enfant est un départ, le parent est un poste
		} else if(element instanceof Departure){
			return ((Departure)element).getStation();
		// si l'enfant est un équipement, le parent est un départ
		} else if(element instanceof Equipment){
			return ((Equipment)element).getDeparture();
		// si l'enfant est une opération, le parent est un equipment
		} else if(element instanceof Operation){
			return ((Operation)element).getEquipment();
		}
	    return null;
	}
 
	/* (non-Javadoc)
	 * @see org.eclipse.jface.databinding.viewers.TreeStructureAdvisor#hasChildren(java.lang.Object)
	 */
	@Override
	public Boolean hasChildren(Object element) {
		if (element instanceof Continent && ((Continent)element).getPays().isEmpty()){
			return true;
		} else if(element instanceof Pays && ((Pays)element).getRegions().isEmpty()){
			return true;
		} else if (element instanceof Region && ((Regions)element).getVilles().isEmpty()){
			return true;
		}  else if (element instanceof Ville){
			return false;
		}		
		return super.hasChildren(element);
	}
}

Ma méthode, createObservable dans TreeFactoryImpl doit retourner un Oberservable de type List

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return BeanProperties.list("pays").observe(parent);

Mais j'ai cette erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
The type org.eclipse.core.databinding.property.list.IListProperty cannot be resolved. It is indirectly referenced from required .class files

[azerr]

Bonjour pingoui,

J'attends avec impatience tes nouveaux billets
S'ils sont aussi bien rédigés que les précédents, je vais me régaler !

Merci c'est gentil, mais la en ce moment c'est impossible pour moi de bosser la dessus. Je n'ai vraiment pas le temps -(

Pour EMF, je n'ai pas bien saisi les avantages ce qui n'arrange pas mes affaires...

Oublie EMF, c'etait juste pour te dire qu'avec EMF ca permettait de s'abstreindre de coder les listener sur tes objets Model. J'ai vu que dans tu as su te debrouiller avec ta classe AbstractModelObject.

Juste pour info, EMF devient de plus en plus important (et il fait tres peur au debut). E4 l'utilise pour modeliser son Workbench dans son IDE ou Eclipse RCP.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

The type org.eclipse.core.databinding.property.list.IListProperty cannot be resolved. It is indirectly referenced from required .class files

Je sais que l'API de JFace Databinding a pas mal evolue ces derniers temps. Je ne sais pas si ton pb est du a ca? Quelle version de Eclipse utilises tu? As tu essaye de faire un import package de org.eclipse.core.databinding.property.list dans ton projet pour vois si tu l'avais?

Tu peux essayer de creer un projet simple avec ton cas de tree et j'essaierai (mais je ne te promets rien) de t'aider.

Angelo

[pingoui]

Salut Angelo,

Juste pour info, EMF devient de plus en plus important (et il fait tres peur au debut). E4 l'utilise pour modeliser son Workbench dans son IDE ou Eclipse RCP.

Effectivement, je vais devoir m'y mettre. Je vais sérieusement me pencher dessus

Je sais que l'API de JFace Databinding a pas mal evolue ces derniers temps. Je ne sais pas si ton pb est du a ca? Quelle version de Eclipse utilises tu? As tu essaye de faire un import package de org.eclipse.core.databinding.property.list dans ton projet pour vois si tu l'avais?

J'utilise eclipse 3.5 Galileo et j'ai bien importé org.eclipse.core.databinding.property.list et org.eclipse.core.databinding.beans.BeanProperties. Je ne sais pas s'il faut faire autre chose.

Tu peux essayer de creer un projet simple avec ton cas de tree et j'essaierai (mais je ne te promets rien) de t'aider.

D'avance merci beaucoup. C'est vraiment sympa

Vince

[Gueritarish]

Salut,

Quelles sont les dépendances que tu as inclus pour JFace data bindings? As-tu inclus org.eclipse.core.databinding?

Voilà, à+
Gueritarish

[pingoui]

Salut Gueritarish,

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Ui
Bundle-SymbolicName: org.pegase.ui; singleton:=true
Bundle-Version: 1.0.0.qualifier
Bundle-Activator: org.pegase.ui.internal.Activator
Bundle-Vendor: ............
Require-Bundle: org.eclipse.ui,
org.eclipse.core.runtime
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Bundle-ActivationPolicy: lazy
Import-Package: org.eclipse.core.databinding,
org.eclipse.core.databinding.beans,
org.eclipse.core.databinding.observable,
org.eclipse.core.databinding.observable.list,
org.eclipse.core.databinding.observable.masterdetail,
org.eclipse.jface.databinding.viewers,
org.eclipse.springframework.util,
org.pegase.domain,
org.pegase.services

Et cette erreur est levée avant la compilation et apparemment, j'ai un problème avec BeanProperties mais je ne comprends pas bien comment fonctionne cette classe.

[Gueritarish]

Ta liste d'imports a l'air bonne

C'est bizarre, t'as essayé de faire un clean ?
Ou encore de supprimer le répertoire "bin" et de re-builder à la main?

[azerr]

J'ai regardé rapidement ton problème. En fait si tu passes la souris sur BeanProperties de ton éditeur Java, tu verras l'erreur suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

The type org.eclipse.core.databinding.property.IProperty cannot be resolved. It is indirectly referenced from required .class files

Cette erreur s'explique par le fait que IListProperty étend IProperty :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
import org.eclipse.core.databinding.property.IProperty;
 
public interface IListProperty extends IProperty {
 
}

Et comme tu peux le voir il faut importer aussi le package org.eclipse.core.databinding.property. Mais je ne te conseille pas d'utiliser import package même si c'est une bonne pratique OSGi.
Dans tous les plugins ou application RCP que j'ai vu, ils utilisent Required-Bundle pour gérer les dépendances. Ce qui donne dans ton cas un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Require-Bundle: org.eclipse.ui,
 org.eclipse.core.runtime,
 org.eclipse.swt.win32.win32.x86.source;bundle-version="3.6.0",
 org.eclipse.core.databinding;bundle-version="1.3.100",
 org.eclipse.jface.databinding;bundle-version="1.4.0",
 org.eclipse.core.databinding.beans;bundle-version="1.2.100",
 org.eclipse.core.databinding.property;bundle-version="1.3.0"

Le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return BeanProperties.list("pays").observe(target);

Signifie que tu souhaites observer la propriété "pays" de ton instance target. Ca te crée une instance de IOBservaleList qui est une notion générique qui indique que l'on observe une liste de quelque chose.

Je pense que si tu nous envoies un mini projet Eclipse avec ton cas ça nous serait plus simple pour t'aider.

Angelo

[pingoui]

Et comme tu peux le voir il faut importer aussi le package org.eclipse.core.databinding.property. Mais je ne te conseille pas d'utiliser import package meme si c'est uen bonne pratique OSGi. Dans tous les plugins ou application RCP que j'ai vu ils utilisent Required-Bundle pour gerer les dependances. Ce qui donne dans ton cas un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Require-Bundle: org.eclipse.ui,
 org.eclipse.core.runtime,
 org.eclipse.swt.win32.win32.x86.source;bundle-version="3.6.0",
 org.eclipse.core.databinding;bundle-version="1.3.100",
 org.eclipse.jface.databinding;bundle-version="1.4.0",
 org.eclipse.core.databinding.beans;bundle-version="1.2.100",
 org.eclipse.core.databinding.property;bundle-version="1.3.0"

Impeccable. J'aurai pu chercher longtemps....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return BeanProperties.list("pays").observe(target);

signifie que tu souhaites observer la proprietes "pays" de ton instance target. Ca te cree une instance de IOBservaleList qui est une notion generique qui indique que l'on observe une list de quelque chose.

En fait ce qui m'intéresse de surveiller, c'est l'ajout de continent, pays, région et ville pour rafraichir mon arbre

Je pense que si tu nous envoie un mini projet eclipse avec ton cas ca nous serait plus simple pour t'aider.

Je vais nettoyer mon projet et remplacer ma bdd par des bouchons.
D'avance merci beaucoup

[azerr]

Bonsoir pingoui,

En fait je ne m'en rappelais plus mais il y a sur le CVS de Eclipse le bundle org.eclipse.jface.examples.databinding qui regorge d'exemples avec JFace Databinding :

Host : dev.eclipse.org
Repository Path: /cvsroot/eclipse
Module : org.eclipse.jface.examples.databinding

Et là, tu as un exemple org.eclipse.jface.examples.databinding.snippets.Snippet019TreeViewerWithListFactory qui devrait te plaire je pense. Ca t'affiche une fenêtre qui affiche un treeview et où tu peux ajouter/supprimer des noeuds et modifier le nom du noeud.

J'ai testé avec la derniere version d'Eclipse 3.6.

Bon courage

Angelo

[pingoui]

Bonsoir,

Désolé de ma réponse tardive... J'ai eu un contretemps au boulot.

Merci pour l'exemple, j'avais commencé à le regarder mais vu que je n'ai pas saisi le fonctionnement, je n'ai pas pu l'appliquer dans mon application

Ci-joint mon projet simplifié avec un début de code pour le databinding dans la vue.
Je souhaiterai faire du dataBinding de mes objets du domain vers mon TreeViewer et du domain vers ma vue.
Dans mon projet, j'ai deux commandes "ajouter" et "supprimer" un objet du domain.

D'avance merci beaucoup pour votre aide et conseils

[azerr]

Bonjour pingoui,

Merci pour ce mini projet. Je ne te promets pas de pouvoir t'aider car il faut que je trouve du temps et je n'ai jamais fait de binding avec un tree. Juste une question as tu compris comment marchait JFace Databinding avec un cas beaucoup plus simple comme un binding entre uen widget Text et une propriete d'un bean (ou POJO). Deja ca c'est la premiere etape je pense. Le binding avec un tree ca m'a l'air plus complique.

Angelo