Index: topia2/src/java/org/codelutin/topia/framework/TopiaContextImplementor.java
diff -u topia2/src/java/org/codelutin/topia/framework/TopiaContextImplementor.java:1.14 topia2/src/java/org/codelutin/topia/framework/TopiaContextImplementor.java:1.15
--- topia2/src/java/org/codelutin/topia/framework/TopiaContextImplementor.java:1.14	Tue Oct 17 13:02:52 2006
+++ topia2/src/java/org/codelutin/topia/framework/TopiaContextImplementor.java	Mon Oct 23 15:01:58 2006
@@ -23,10 +23,10 @@
  * Created: 3 janv. 2006 21:27:24
  *
  * @author poussin
- * @version $Revision: 1.14 $
+ * @version $Revision: 1.15 $
  *
- * Last update: $Date: 2006/10/17 13:02:52 $
- * by : $Author: bpoussin $
+ * Last update: $Date: 2006/10/23 15:01:58 $
+ * by : $Author: ruchaud $
  */
 
 package org.codelutin.topia.framework;
@@ -101,106 +101,9 @@
     public <E extends TopiaEntity> TopiaDAO<E> getDAO(Class<E> entityClass)
             throws TopiaException;
 
-    /**
-     * Retourne tous les listeners
-     */
-    public CategorisedListenerSet getListeners();
-
-    /**
-     * Retourne tous les loadListeners
-     */
-    public CategorisedListenerSet getLoadListeners();
-
-    /**
-     * @return Returns the vetoableListeners.
-     */
-    public ListenerSet getVetoableListeners();
-
-    /**
-     * @return Returns the vetoableLoadListeners.
-     */
-    public ListenerSet getVetoableLoadListeners();
-
-    /**
-     * @return Returns the transactionListeners.
-     */
-    public ListenerSet getTransactionListeners();
-
-    /**
-     * Appele avant de charger un objet, le listener peut lever une exception
-     * s'il ne souhaite pas que l'objet soit chargé
-     * @param id identifiant de l'objet a charger
-     * @throws Exception If one listener don't accepte this action
-     */
-    public boolean fireVetoableLoad(Class entityClass, Object id);
-
-    /**
-     * Appele avant de creer un objet, le listener peut lever une exception
-     * s'il ne souhaite pas que l'objet soit cree
-     * @param id identifiant de l'objet a creer
-     * @throws Exception If one listener don't accepte this action
-     */
-    public void fireVetoableCreate(Class entityClass, Object id);
-
-    /**
-     * Appele avant d'updater un objet, le listener peut lever une exception
-     * s'il ne souhaite pas que l'objet soit updater
-     * @param id identifiant de l'objet a updater
-     * @throws Exception If one listener don't accepte this action
-     */
-    public void fireVetoableUpdate(Class entityClass, Object id);
 
-    /**
-     * Appele avant de supprimer un objet, le listener peut lever une exception
-     * s'il ne souhaite pas que l'objet soit supprimé
-     * @param id identifiant de l'objet a supprimé
-     * @throws Exception If one listener don't accepte this action
-     */
-    public void fireVetoableDelete(Class entityClass, Object id);
-    
-    /**
-     * Appeler avant le chargement d'une entity (remise en place des proprietes)
-     * @param entity l'entite qui vient d'etre chargée
-     */
-    public void fireOnPreLoaded(Class entityClass, Object id, Object entity);
-    
-    /**
-     * Appeler apres le chargement d'une entity
-     * @param entity l'entite qui vient d'etre chargée
-     */
-    public void fireOnLoaded(Class entityClass, Object id, Object entity);
+    public TopiaFiresSupport getFiresSupport();
     
-    /**
-     * Appeler apres la creation d'une entity
-     * @param entity l'entite qui vient d'etre creee
-     * @param fields la valeur des champs de l'entity tel que stocké
-     */
-    public void fireOnCreated(Class entityClass, Object id, Object entity);
-
-    /**
-     * Appeler apres la mise a jour d'une entity
-     * @param entity l'entite qui vient d'etre modifee
-     * @param fields la valeur des champs de l'entity tel que stocké
-     */
-    public void fireOnUpdated(Class entityClass, Object id, Object entity);
-
-    /**
-     * Appeler apres l'effacement d'une entity
-     * @param entity l'entite qui vient d'etre effacée
-     * @param fields la valeur des champs de l'entity tel que stocké
-     */
-    public void fireOnDeleted(Class entityClass, Object id, Object entity);
-
-    /**
-     * Appeler apres le commit d'une transaction
-     */
-    public void fireOnCommited();
-
-    /**
-     * Appeler apres le rollback d'une transaction
-     */
-    public void fireOnRollbacked();
-
     public void removeChildContext(TopiaContextImplementor child);
     
     public boolean serviceEnabled(String name);

Index: topia2/src/java/org/codelutin/topia/framework/TopiaContextImpl.java
diff -u topia2/src/java/org/codelutin/topia/framework/TopiaContextImpl.java:1.41 topia2/src/java/org/codelutin/topia/framework/TopiaContextImpl.java:1.42
--- topia2/src/java/org/codelutin/topia/framework/TopiaContextImpl.java:1.41	Wed Oct 18 08:44:23 2006
+++ topia2/src/java/org/codelutin/topia/framework/TopiaContextImpl.java	Mon Oct 23 15:01:58 2006
@@ -23,9 +23,9 @@
  * 
  * @author poussin
  * 
- * @version $Revision: 1.41 $
+ * @version $Revision: 1.42 $
  * 
- * Last update: $Date: 2006/10/18 08:44:23 $ by : $Author: ruchaud $
+ * Last update: $Date: 2006/10/23 15:01:58 $ by : $Author: ruchaud $
  */
 
 package org.codelutin.topia.framework;
@@ -52,7 +52,6 @@
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
@@ -66,26 +65,15 @@
 import org.codelutin.topia.TopiaContext;
 import org.codelutin.topia.TopiaException;
 import org.codelutin.topia.TopiaNotFoundException;
-import org.codelutin.topia.TopiaVetoException;
-import org.codelutin.topia.event.TopiaEntityEvent;
 import org.codelutin.topia.event.TopiaEntityListener;
-import org.codelutin.topia.event.TopiaEntityLoadEvent;
-import org.codelutin.topia.event.TopiaEntityLoadListener;
-import org.codelutin.topia.event.TopiaTransactionEvent;
-import org.codelutin.topia.event.TopiaTransactionEvents;
+import org.codelutin.topia.event.TopiaEntityVetoable;
 import org.codelutin.topia.event.TopiaTransactionListener;
-import org.codelutin.topia.event.TopiaVetoableEntityEvent;
-import org.codelutin.topia.event.TopiaVetoableEntityListener;
-import org.codelutin.topia.event.TopiaVetoableEntityLoadEvent;
-import org.codelutin.topia.event.TopiaVetoableEntityLoadListener;
+import org.codelutin.topia.event.TopiaTransactionVetoable;
 import org.codelutin.topia.persistence.TopiaDAO;
 import org.codelutin.topia.persistence.TopiaDAODelegator;
 import org.codelutin.topia.persistence.TopiaEntity;
-import org.codelutin.topia.persistence.TopiaEntityAbstract;
 import org.codelutin.topia.persistence.TopiaId;
 import org.codelutin.util.ArrayUtil;
-import org.codelutin.util.CategorisedListenerSet;
-import org.codelutin.util.ListenerSet;
 import org.dom4j.Document;
 import org.dom4j.DocumentException;
 import org.dom4j.DocumentFactory;
@@ -102,17 +90,13 @@
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
-import org.hibernate.event.PostDeleteEvent;
 import org.hibernate.event.PostDeleteEventListener;
-import org.hibernate.event.PostLoadEvent;
+import org.hibernate.event.PostInsertEventListener;
 import org.hibernate.event.PostLoadEventListener;
-import org.hibernate.event.PostUpdateEvent;
 import org.hibernate.event.PostUpdateEventListener;
-import org.hibernate.event.PreDeleteEvent;
 import org.hibernate.event.PreDeleteEventListener;
-import org.hibernate.event.PreLoadEvent;
+import org.hibernate.event.PreInsertEventListener;
 import org.hibernate.event.PreLoadEventListener;
-import org.hibernate.event.PreUpdateEvent;
 import org.hibernate.event.PreUpdateEventListener;
 import org.hibernate.tool.hbm2ddl.SchemaExport;
 import org.hibernate.tool.hbm2ddl.SchemaUpdate;
@@ -153,12 +137,6 @@
 
     static final private String TOPIA_PERSISTENCE_PROPERTIES_FILE = "topia.persistence.properties.file";
 
-    static final private String TOPIA_SECURITY_MANAGER = "topia.security.manager";
-    
-    static final private String TOPIA_INDEX_ENGIN = "topia.index.engin";
-
-    static final private String TOPIA_HISTORY = "topia.history";
-
     /**
      * Le pere de ce context, les contexts initaux n'ont pas de context pere
      */
@@ -201,21 +179,12 @@
      */
     protected Map<TopiaContextImplementor, Object> childContext = new WeakHashMap<TopiaContextImplementor, Object>();
 
-    protected CategorisedListenerSet listeners = new CategorisedListenerSet<TopiaEntityListener>();
-
-    protected CategorisedListenerSet loadListeners = new CategorisedListenerSet<TopiaEntityLoadListener>();
-
-    protected ListenerSet vetoableListeners = new ListenerSet<TopiaVetoableEntityListener>();
-
-    protected ListenerSet vetoableLoadListeners = new ListenerSet<TopiaVetoableEntityLoadListener>();
-
-    protected ListenerSet transactionListeners = new ListenerSet<TopiaTransactionListener>();
-    
-    protected List<TopiaTransactionEvent> transactionEvents = new LinkedList<TopiaTransactionEvent>();
-
     /** key: service name; value: service instance */
     protected Map<String, TopiaService> services = null;
     
+    /** */
+    protected TopiaFiresSupport firesSupport = new TopiaFiresSupport();
+    
     /**
      * constructeur utilisé par la factory pour creer les contexts initiaux
      * 
@@ -426,8 +395,13 @@
                 hibernateConfiguration = new Configuration();
 
                 // Ajout du listeners pour les events
-                TopiaHibernateEvent listener = new TopiaHibernateEvent(this);
+                TopiaFiresSupport.TopiaHibernateEvent listener =
+                    new TopiaFiresSupport.TopiaHibernateEvent(this);
 
+                PreInsertEventListener[] preInsertEventListeners = hibernateConfiguration
+                        .getEventListeners().getPreInsertEventListeners();
+                preInsertEventListeners = ArrayUtil.concatElems(
+                        preInsertEventListeners, listener);
                 PreLoadEventListener[] preLoadEventListeners = hibernateConfiguration
                         .getEventListeners().getPreLoadEventListeners();
                 preLoadEventListeners = ArrayUtil.concatElems(
@@ -441,6 +415,10 @@
                 preDeleteEventListeners = ArrayUtil.concatElems(
                         preDeleteEventListeners, listener);
 
+                PostInsertEventListener[] postInsertEventListeners = hibernateConfiguration
+                        .getEventListeners().getPostInsertEventListeners();
+                postInsertEventListeners = ArrayUtil.concatElems(
+                        postInsertEventListeners, listener);
                 PostLoadEventListener[] postLoadEventListeners = hibernateConfiguration
                         .getEventListeners().getPostLoadEventListeners();
                 postLoadEventListeners = ArrayUtil.concatElems(
@@ -454,6 +432,8 @@
                 postDeleteEventListeners = ArrayUtil.concatElems(
                         postDeleteEventListeners, listener);
 
+                hibernateConfiguration.getEventListeners().setPreInsertEventListeners(
+                        preInsertEventListeners);
                 hibernateConfiguration.getEventListeners().setPreLoadEventListeners(
                         preLoadEventListeners);
                 hibernateConfiguration.getEventListeners().setPreUpdateEventListeners(
@@ -461,6 +441,8 @@
                 hibernateConfiguration.getEventListeners().setPreDeleteEventListeners(
                         preDeleteEventListeners);
 
+                hibernateConfiguration.getEventListeners().setPostInsertEventListeners(
+                        postInsertEventListeners);
                 hibernateConfiguration.getEventListeners().setPostLoadEventListeners(
                         postLoadEventListeners);
                 hibernateConfiguration.getEventListeners().setPostUpdateEventListeners(
@@ -589,134 +571,6 @@
         return result;
     }
 
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#getListeners()
-     */
-    public CategorisedListenerSet getListeners() {
-        return listeners;
-    }
-
-    public CategorisedListenerSet getLoadListeners() {
-        return loadListeners;
-    }
-
-    public ListenerSet getVetoableListeners() {
-        return this.vetoableListeners;
-    }
-
-    public ListenerSet getVetoableLoadListeners() {
-        return vetoableLoadListeners;
-    }
-
-    /**
-     * @return Returns the transactionListeners.
-     */
-    public ListenerSet getTransactionListeners() {
-        return this.transactionListeners;
-    }
-    
-    public void addVetoableListener(TopiaVetoableEntityListener l) {
-        this.vetoableListeners.add(l);
-    }
-
-    public void removeVetoableListener(TopiaVetoableEntityListener l) {
-        this.vetoableListeners.remove(l);
-    }
-    
-    public void addVetoableLoadListener(TopiaVetoableEntityLoadListener l) {
-        this.vetoableLoadListeners.add(l);
-    }
-
-    public void removeVetoableLoadListener(TopiaVetoableEntityLoadListener l) {
-        this.vetoableLoadListeners.remove(l);
-    }
-    
-    public void addTransactionListener(TopiaTransactionListener l) {
-        this.transactionListeners.add(l);
-    }
-
-    public void removeTransactionListener(TopiaTransactionListener l) {
-        this.transactionListeners.remove(l);
-    }
-    
-    /*
-     * (non-Javadoc)
-     * 
-     * @see org.codelutin.topia.TopiaContext#addTopiaEntityListener(org.codelutin.topia.event.TopiaEntityListener)
-     */
-    public void addTopiaEntityListener(TopiaEntityListener l) {
-        // Quoi qu'il arrive une entity herite toujours de Objet
-        // Donc si on veut recevoir tous les events, il suffit de
-        // s'enregistrer sur la class Objet. Le CategorisedListenerSet
-        // fait le reste
-        addTopiaEntityListener(Object.class, l);
-    }
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see org.codelutin.topia.TopiaContext#addTopiaEntityListener(java.lang.Class,
-     *      org.codelutin.topia.event.TopiaEntityListener)
-     */
-    public void addTopiaEntityListener(Class entityClass, TopiaEntityListener l) {
-        getListeners().add(entityClass, l);
-    }
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see org.codelutin.topia.TopiaContext#removeTopiaEntityListener(org.codelutin.topia.event.TopiaEntityListener)
-     */
-    public void removeTopiaEntityListener(TopiaEntityListener l) {
-        removeTopiaEntityListener(Object.class, l);
-    }
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see org.codelutin.topia.TopiaContext#removeTopiaEntityListener(java.lang.Class,
-     *      org.codelutin.topia.event.TopiaEntityListener)
-     */
-    public void removeTopiaEntityListener(Class entityClass,
-            TopiaEntityListener l) {
-        getListeners().remove(entityClass, l);
-    }
-
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.TopiaContext#addTopiaEntityLoadListener(
-     *     org.codelutin.topia.event.TopiaEntityLoadListener)
-     */
-    public void addTopiaEntityLoadListener(TopiaEntityLoadListener l) {
-        addTopiaEntityLoadListener(Object.class, l);
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.TopiaContext#addTopiaEntityLoadListener(
-     *     java.lang.Class, org.codelutin.topia.event.TopiaEntityLoadListener)
-     */
-    public void addTopiaEntityLoadListener(Class entityClass,
-            TopiaEntityLoadListener l) {
-        getLoadListeners().add(entityClass, l);
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.TopiaContext#removeTopiaEntityLoadListener(
-     *     org.codelutin.topia.event.TopiaEntityLoadListener)
-     */
-    public void removeTopiaEntityLoadListener(TopiaEntityLoadListener l) {
-        removeTopiaEntityLoadListener(Object.class, l);
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.TopiaContext#removeTopiaEntityLoadListener(
-     *     java.lang.Class, org.codelutin.topia.event.TopiaEntityLoadListener)
-     */
-    public void removeTopiaEntityLoadListener(Class entityClass,
-            TopiaEntityLoadListener l) {
-        getLoadListeners().remove(entityClass, l);
-    }
-
     /*
      * (non-Javadoc)
      * 
@@ -725,6 +579,7 @@
     public TopiaContext beginTransaction() throws TopiaException {
         checkClosed("Ce contexte a ete ferme, impossible de commencer une transaction");
         TopiaContextImpl result = new TopiaContextImpl(this);
+        getFiresSupport().fireOnPreCommit(result);
         addChildContext(result);
         SessionFactory factory = getHibernateFactory();
         result.hibernate = factory.openSession();
@@ -764,12 +619,18 @@
 //            Transaction tx = hibernate.beginTransaction();
             hibernate.flush();
             tx.commit();
+            
+            getFiresSupport().fireOnPostCommit(this);
+            TopiaContextImplementor parent = getParentContext();
+            if(parent != null) {
+                parent.getFiresSupport().fireOnPostCommit(this);
+            }
+
             hibernate.beginTransaction();
             // it's seem necessary to change session after commit
             // NON, NON, NON, il ne faut surtout pas le faire, ca pose plein de probleme 
 //            hibernate = getHibernateFactory().openSession();
 //            hibernate.setFlushMode(FlushMode.NEVER);
-            fireOnCommited();
         } catch (Exception eee) {
             throw new TopiaException("Error during commit", eee);
         }
@@ -800,9 +661,14 @@
             hibernate = getHibernateFactory().openSession();
             hibernate.setFlushMode(FlushMode.NEVER);
             
+            getFiresSupport().fireOnPostRollback(this);
+            TopiaContextImplementor parent = getParentContext();
+            if(parent != null) {
+                parent.getFiresSupport().fireOnPostRollback(this);
+            }
+            
             hibernate.beginTransaction();
 
-            fireOnRollbacked();
         } catch (HibernateException eee) {
             throw new TopiaException(eee);
         }
@@ -974,476 +840,14 @@
         }
     }
 
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireVetoableLoad(java.lang.Class, java.lang.Object)
-     */
-    public boolean fireVetoableLoad(Class entityClass, Object id) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireVetoableLoad: " + id);
-        }
-        try {
-            boolean result = true;
-            TopiaVetoableEntityLoadEvent event = new TopiaVetoableEntityLoadEvent(this, entityClass, id);
-            for(Iterator<TopiaVetoableEntityLoadListener> l=getVetoableLoadListeners().iterator(); l.hasNext();) {
-                result &= l.next().loadEntity(event);
-            }
-            if (getParentContext() != null) {
-                result &= getParentContext().fireVetoableLoad(entityClass, id);
-            }
-            return result;
-        } catch (Exception eee) {
-            throw new TopiaVetoException(eee);
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireVetoableCreate(java.lang.Class, java.lang.Object)
-     */
-    public void fireVetoableCreate(Class entityClass, Object id) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireVetoableCreate: " + id);
-        }
-        try {
-            TopiaVetoableEntityEvent event = new TopiaVetoableEntityEvent(this, entityClass, id);
-            for(Iterator<TopiaVetoableEntityListener> l=getVetoableListeners().iterator(); l.hasNext();) {
-                l.next().createEntity(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireVetoableCreate(entityClass, id);
-            }
-        } catch (Exception eee) {
-            throw new TopiaVetoException(eee);
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireVetoableUpdate(java.lang.Class, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * @see org.codelutin.topia.framework.TopiaContextImplementor#getFiresSupport()
      */
-    public void fireVetoableUpdate(Class entityClass, Object id) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireVetoableUpdate: " + id);
-        }
-        try {
-            TopiaVetoableEntityEvent event = new TopiaVetoableEntityEvent(this, entityClass, id);
-            for(Iterator<TopiaVetoableEntityListener> l=getVetoableListeners().iterator(); l.hasNext();) {
-                l.next().updateEntity(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireVetoableUpdate(entityClass, id);
-            }
-        } catch (Exception eee) {
-            throw new TopiaVetoException(eee);
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireVetoableDelete(java.lang.Class, java.lang.Object)
-     */
-    public void fireVetoableDelete(Class entityClass, Object id) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireVetoableDelete: " + id);
-        }
-        try {
-            TopiaVetoableEntityEvent event = new TopiaVetoableEntityEvent(this, entityClass, id);
-            for(Iterator<TopiaVetoableEntityListener> l=getVetoableListeners().iterator(); l.hasNext();) {
-                l.next().deleteEntity(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireVetoableDelete(entityClass, id);
-            }
-        } catch (Exception eee) {
-            throw new TopiaVetoException(eee);
-        }
+    public TopiaFiresSupport getFiresSupport() {
+        return firesSupport;
     }
     
-    
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnPreLoad(java.lang.Class, java.lang.Object, java.lang.Object)
-     */
-    public void fireOnPreLoaded(Class entityClass, Object id, Object entity) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireOnPreLoad: " + entity);
-        }
-
-        if (entity instanceof TopiaEntityAbstract) {
-            TopiaEntityAbstract entityAbstract = (TopiaEntityAbstract) entity;
-            //On ne rattache l'entité à un contexte que si elle n'en a pas
-            if (entityAbstract.getTopiaContext() == null) {
-                try {
-                    entityAbstract.setInPreLoaded(true);
-                    entityAbstract.setTopiaContext(this);
-                } catch (TopiaException eee) {
-                    if (log.isWarnEnabled()) {
-                        log.warn("Impossible d'initialiser le TopiaContext" +
-                                " sur cette entité : " + entityAbstract, eee);
-                    }
-                }
-            }
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnLoaded(java.lang.Class, java.lang.Object, java.lang.Object)
-     */
-    public void fireOnLoaded(Class entityClass, Object id, Object entity) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireOnLoaded: " + entity);
-        }
-
-        if (entity instanceof TopiaEntityAbstract) {
-            TopiaEntityAbstract entityAbstract = (TopiaEntityAbstract) entity;
-            entityAbstract.setInPreLoaded(false);
-            //On ne rattache l'entité à un contexte que si elle n'en a pas
-            if (entityAbstract.getTopiaContext() == null) {
-                try {
-                    entityAbstract.setTopiaContext(this);
-                } catch (TopiaException eee) {
-                    if (log.isWarnEnabled()) {
-                        log.warn("Impossible d'initialiser le TopiaContext" +
-                                " sur cette entité : " + entityAbstract, eee);
-                    }
-                }
-            }
-            try {
-                entityAbstract.postLoad();
-            } catch (TopiaException eee) {
-                if (log.isWarnEnabled()) {
-                    log.warn("Can't call postLoad for this entity : " + entityAbstract, eee);
-                }
-            }
-        }
-        try {
-            TopiaEntityLoadEvent event = new TopiaEntityLoadEvent(this, entity);
-            // NON, NON, NON, il ne faut pas ajouter cette entity dans les events
-            // de transaction, c un load pas une modif :(
-//            transactionEvents.add(new TopiaTransactionEvent(this, entityClass, id));
-            for(Iterator<TopiaEntityLoadListener> l=getLoadListeners().iterator(entity.getClass()); l.hasNext();) {
-                l.next().entityLoaded(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireOnLoaded(entityClass, id, entity);
-            }
-        } catch (Exception eee) {
-            if (log.isErrorEnabled()) {
-                log.error("Can't fire event loaded for entity: " + entity, eee);
-            }
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnCreated(java.lang.Class, java.lang.Object, java.lang.Object)
-     */
-    public void fireOnCreated(Class entityClass, Object id, Object entity) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireOnCreated: " + entity);
-        }
-        if (entity instanceof TopiaEntityAbstract) {
-            TopiaEntityAbstract entityAbstract = (TopiaEntityAbstract) entity;
-            //On ne rattache l'entité à un contexte que si elle n'en a pas
-            if (entityAbstract.getTopiaContext() == null) {
-                try {
-                    entityAbstract.setTopiaContext(this);
-                } catch (TopiaException te) {
-                    if (log.isWarnEnabled()) {
-                        log.warn("Impossible d'initialiser le TopiaContext" +
-                                " sur cette entité : " + entityAbstract, te);
-                    }
-                }
-            }
-            try {
-                entityAbstract.postCreate();
-            } catch (TopiaException eee) {
-                if (log.isWarnEnabled()) {
-                    log.warn("Can't call postCreate for this entity : " + entityAbstract, eee);
-                }
-            }
-        }
-        try {
-            TopiaEntityEvent event = new TopiaEntityEvent(this, entity);
-            transactionEvents.add(TopiaTransactionEvent.create(this, entityClass, id));
-            for(Iterator<TopiaEntityListener> l=getListeners().iterator(entity.getClass()); l.hasNext();) {
-                l.next().entityCreated(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireOnCreated(entityClass, id, entity);
-            }
-        } catch (Exception eee) {
-            if (log.isWarnEnabled()) {
-                log.warn("Can't fire event created for entity: " + entity, eee);
-            }
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnUpdated(java.lang.Class, java.lang.Object, java.lang.Object)
-     */
-    public void fireOnUpdated(Class entityClass, Object id, Object entity) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireOnUpdated: (" + entityClass + ")" + entity);
-        }
-        try {
-            TopiaEntityEvent event = new TopiaEntityEvent(this, entity);
-            transactionEvents.add(TopiaTransactionEvent.update(this, entityClass, id));
-            for(Iterator<TopiaEntityListener> l=getListeners().iterator(entity.getClass()); l.hasNext();) {
-                l.next().entityUpdated(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireOnUpdated(entityClass, id, entity);
-            }
-        } catch (Exception eee) {
-            if (log.isWarnEnabled()) {
-                log.warn("Can't fire event updated for entity: " + entity, eee);
-            }
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnDeleted(java.lang.Class, java.lang.Object, java.lang.Object)
-     */
-    public void fireOnDeleted(Class entityClass, Object id, Object entity) {
-        if (log.isDebugEnabled()) {
-            log.debug("fireOnDeleted: " + entity);
-        }
-        try {
-            TopiaEntityEvent event = new TopiaEntityEvent(this, entity);
-            transactionEvents.add(TopiaTransactionEvent.delete(this, entityClass, id));
-            for(Iterator<TopiaEntityListener> l=getListeners().iterator(entity.getClass()); l.hasNext();) {
-                l.next().entityDeleted(event);
-            }
-            if (getParentContext() != null) {
-                getParentContext().fireOnDeleted(entityClass, id, entity);
-            }
-        } catch (Exception eee) {
-            if (log.isWarnEnabled()) {
-                log.warn("Can't fire event deleted for entity: " + entity, eee);
-            }
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnCommited()
-     */
-    public void fireOnCommited() {
-        if (log.isInfoEnabled()) {
-            log.info("onCommited");
-        }
-        try {
-            TopiaTransactionEvents e = null;
-            for(Iterator<TopiaTransactionListener> l=getTransactionListeners().iterator(); l.hasNext();) {
-                // on cree l'event que si on en a besoin
-                if (e == null) {
-                    e = new TopiaTransactionEvents(this, transactionEvents);
-                }
-                l.next().commit(e);
-            }
-            // poussin FIXME: il faut bien prevenir notre pere, mais je ne pense
-            // pas que ce soit le bon moyen. Je pense qu'il faut une methode
-            // specifique pour cela, sans doute le pere peut-il etre listener
-            // sur le fils ?
-            if (getParentContext() != null) {
-                getParentContext().fireOnCommited();
-            }
-// FIXME indexation            if (isIndexEnabled()) {
-//                getIndexEnginImplementor().doIndexation();
-//            }
-        } catch (Exception eee) {
-            if (log.isWarnEnabled()) {
-                log.warn("Can't fire event commit for entity", eee);
-            }
-        } finally {
-            transactionEvents.clear();
-// FIXME indexation           if (isIndexEnabled()) {
-//                getIndexEnginImplementor().clearLastRecordedIndexation();
-//            }
-        }
-    }
-
-    /* (non-Javadoc)
-     * @see org.codelutin.topia.framework.TopiaContextImplementor#fireOnRollbacked()
-     */
-    public void fireOnRollbacked() {
-        if (log.isInfoEnabled()) {
-            log.info("onRollbacked");
-        }
-        try {
-            TopiaTransactionEvents e = null;
-            for(Iterator<TopiaTransactionListener> l=getTransactionListeners().iterator(); l.hasNext();) {
-                // on cree l'event que si on en a besoin
-                if (e == null) {
-                    e = new TopiaTransactionEvents(this, transactionEvents);
-                }
-                l.next().rollback(e);
-            }
-        } catch (Exception eee) {
-            if (log.isWarnEnabled()) {
-                log.warn("Can't fire event rollback for entity", eee);
-            }
-        } finally {
-            transactionEvents.clear();
-// FIXME indexation           if (isIndexEnabled()) {
-//                getIndexEnginImplementor().clearLastRecordedIndexation();
-//            }
-        }
-    }
-        
-    /**
-     * Object permettant de faire le lien entre les events hibernate et topia
-     * 
-     * @author poussin
-     */
-    static protected class TopiaHibernateEvent implements
-            PostDeleteEventListener, PostLoadEventListener,
-            PostUpdateEventListener, PreDeleteEventListener,
-            PreLoadEventListener, PreUpdateEventListener {
-
-        /**  */
-        private static final long serialVersionUID = 7303593133642169218L;
-
-        protected TopiaContextImplementor rootContext;
-
-        /**
-         * 
-         */
-        public TopiaHibernateEvent(TopiaContextImplementor rootContext) {
-            this.rootContext = rootContext;
-        }
-
-        /**
-         * Recherche le context utilisant la session hibernate passe en
-         * parametre
-         * 
-         * @param hibernate la session hibernate que doit utiliser le
-         *        TopiaContext pour etre retourne
-         * @return le TopiaContext utilisant cette session hibernate ou null si
-         *         aucun TopiaContext n'utilise cette session.
-         */
-        protected TopiaContextImplementor getContext(
-                TopiaContextImplementor parent, Session hibernate) {
-            TopiaContextImplementor result = null;
-            for (TopiaContextImplementor context : parent.getChildContext()) {
-                try {
-                    if (context.getHibernate() == hibernate) {
-                        result = context;
-                    } else {
-                        result = getContext(context, hibernate);
-                    }
-                    if (result != null) {
-                        break;
-                    }
-                } catch (TopiaException eee) {
-                    if (log.isWarnEnabled()) {
-                        log.warn("Error durant la recherche d'un context pour"
-                                + " lancer un event", eee);
-                    }
-                }
-            }
-            return result;
-        }
-
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.hibernate.event.PreLoadEventListener#onPreLoad(org.hibernate.event.PreLoadEvent)
-         */
-        public void onPreLoad(PreLoadEvent event) {
-            TopiaContextImplementor context = getContext(rootContext, event
-                    .getSession());
-            if (context != null) {
-                boolean loadAuthorised = true;
-                loadAuthorised &= context.fireVetoableLoad(event.getPersister().getMappedClass(
-                        EntityMode.POJO), event.getId());
-                if (!loadAuthorised) {
-                    throw new SecurityException("User is not authorised to load this entity : " + event.getId());
-                }
-                context.fireOnPreLoaded(event.getPersister().getMappedClass(
-                        EntityMode.POJO), event.getId(), event.getEntity());
-            }
-        }
-
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.hibernate.event.PreUpdateEventListener#onPreUpdate(org.hibernate.event.PreUpdateEvent)
-         */
-        public boolean onPreUpdate(PreUpdateEvent event) {
-            TopiaContextImplementor context = getContext(rootContext, event
-                    .getSession());
-            if (context != null) {
-                context.fireVetoableUpdate(event.getPersister().getMappedClass(
-                        EntityMode.POJO), event.getId());
-            }
-            return false;
-        }
-
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.hibernate.event.PreDeleteEventListener#onPreDelete(org.hibernate.event.PreDeleteEvent)
-         */
-        public boolean onPreDelete(PreDeleteEvent event) {
-            TopiaContextImplementor context = getContext(rootContext, event
-                    .getSession());
-            if (context != null) {
-                context.fireVetoableDelete(event.getPersister().getMappedClass(
-                        EntityMode.POJO), event.getId());
-            }
-            return false;
-        }
-
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.hibernate.event.PostLoadEventListener#onPostLoad(org.hibernate.event.PostLoadEvent)
-         */
-        public void onPostLoad(PostLoadEvent event) {
-            TopiaContextImplementor context = getContext(rootContext, event
-                    .getSession());
-            if (context != null) {
-                context.fireOnLoaded(event.getPersister().getMappedClass(
-                        EntityMode.POJO), event.getId(), event.getEntity());
-            }
-        }
-
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.hibernate.event.PostUpdateEventListener#onPostUpdate(org.hibernate.event.PostUpdateEvent)
-         */
-        public void onPostUpdate(PostUpdateEvent event) {
-            TopiaContextImplementor context = getContext(rootContext, event
-                    .getSession());
-            if (context != null) {
-                Object id = event.getId();
-                Object entity = event.getEntity();
-                context.fireOnUpdated(event.getPersister().getMappedClass(
-                        EntityMode.POJO), id, entity);
-// FIXME indexation               if (!(entity instanceof NotIndexable) && context.isIndexEnabled()) {
-//                    context.getIndexEnginImplementor().recordForIndexation(id, event.getState());
-//                }
-            }
-        }
-
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.hibernate.event.PostDeleteEventListener#onPostDelete(org.hibernate.event.PostDeleteEvent)
-         */
-        public void onPostDelete(PostDeleteEvent event) {
-            TopiaContextImplementor context = getContext(rootContext, event
-                    .getSession());
-            if (context != null) {
-                Object id = event.getId();
-                Object entity = event.getEntity();
-                context.fireOnDeleted(event.getPersister().getMappedClass(
-                        EntityMode.POJO), id, entity);
-// FIXME indexation               if (!(entity instanceof NotIndexable) && context.isIndexEnabled()) {
-//                    context.getIndexEnginImplementor().recordForIndexation(id, null);
-//                }
-            }
-        }
-    }
-
     /**
      * Backup database in gzip compressed file
      * Only work for h2 database
@@ -1566,4 +970,54 @@
         }
    }
 
+    /* Adders */
+    public void addTopiaEntityListener(TopiaEntityListener listener) {
+        getFiresSupport().addTopiaEntityListener(listener);
+    }
+
+    public void addTopiaEntityListener(Class<TopiaEntity> entityClass, TopiaEntityListener listener) {
+        getFiresSupport().addTopiaEntityListener(entityClass, listener);
+    }
+
+    public void addTopiaEntityVetoable(TopiaEntityVetoable vetoable) {
+        getFiresSupport().addTopiaEntityVetoable(TopiaEntity.class, vetoable);
+    }
+
+    public void addTopiaEntityVetoable(Class<TopiaEntity> entityClass, TopiaEntityVetoable vetoable) {
+        getFiresSupport().addTopiaEntityVetoable(entityClass, vetoable);
+    }
+
+    public void addTopiaTransactionListener(TopiaTransactionListener listener) {
+        getFiresSupport().addTopiaTransactionListener(listener);
+    }
+
+    public void addTopiaTransactionVetoable(TopiaTransactionVetoable vetoable) {
+        getFiresSupport().addTopiaTransactionVetoable(vetoable);
+    }
+    
+    /* Removers */
+    public void removeTopiaEntityListener(TopiaEntityListener listener) {
+        getFiresSupport().removeTopiaEntityListener(TopiaEntity.class, listener);
+    }
+
+    public void removeTopiaEntityListener(Class<TopiaEntity> entityClass, TopiaEntityListener listener) {
+        getFiresSupport().removeTopiaEntityListener(entityClass, listener);
+    }
+
+    public void removeTopiaEntityVetoable(TopiaEntityVetoable vetoable) {
+        getFiresSupport().removeTopiaEntityVetoable(TopiaEntity.class, vetoable);
+    }
+
+    public void removeTopiaEntityVetoable(Class<TopiaEntity> entityClass, TopiaEntityVetoable vetoable) {
+        getFiresSupport().removeTopiaEntityVetoable(entityClass, vetoable);
+    }
+
+    public void removeTopiaTransactionListener(TopiaTransactionListener listener) {
+        getFiresSupport().removeTopiaTransactionListener(listener);
+    }
+
+    public void removeTopiaTransactionVetoable(TopiaTransactionVetoable vetoable) {
+        getFiresSupport().removeTopiaTransactionVetoable(vetoable);
+    }
+
 } //TopiaContextImpl

Index: topia2/src/java/org/codelutin/topia/framework/TopiaFiresSupport.java
diff -u /dev/null topia2/src/java/org/codelutin/topia/framework/TopiaFiresSupport.java:1.1
--- /dev/null	Mon Oct 23 15:02:03 2006
+++ topia2/src/java/org/codelutin/topia/framework/TopiaFiresSupport.java	Mon Oct 23 15:01:58 2006
@@ -0,0 +1,552 @@
+/*
+ * *##% Copyright (C) 2005 Code Lutin, Cédric Pineau, Benjamin Poussin
+ * 
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307, USA. ##%
+ */
+
+package org.codelutin.topia.framework;
+
+import java.beans.PropertyChangeSupport;
+import java.beans.VetoableChangeSupport;
+import java.util.Iterator;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.codelutin.topia.TopiaContext;
+import org.codelutin.topia.TopiaException;
+import org.codelutin.topia.TopiaVetoException;
+import org.codelutin.topia.event.TopiaEntityEvent;
+import org.codelutin.topia.event.TopiaEntityListener;
+import org.codelutin.topia.event.TopiaEntityVetoable;
+import org.codelutin.topia.event.TopiaTransactionEvent;
+import org.codelutin.topia.event.TopiaTransactionListener;
+import org.codelutin.topia.event.TopiaTransactionVetoable;
+import org.codelutin.topia.persistence.TopiaEntity;
+import org.codelutin.topia.persistence.TopiaEntityAbstract;
+import org.codelutin.util.CategorisedListenerSet;
+import org.codelutin.util.ListenerSet;
+import org.hibernate.Session;
+import org.hibernate.event.PostDeleteEvent;
+import org.hibernate.event.PostDeleteEventListener;
+import org.hibernate.event.PostInsertEvent;
+import org.hibernate.event.PostInsertEventListener;
+import org.hibernate.event.PostLoadEvent;
+import org.hibernate.event.PostLoadEventListener;
+import org.hibernate.event.PostUpdateEvent;
+import org.hibernate.event.PostUpdateEventListener;
+import org.hibernate.event.PreDeleteEvent;
+import org.hibernate.event.PreDeleteEventListener;
+import org.hibernate.event.PreInsertEvent;
+import org.hibernate.event.PreInsertEventListener;
+import org.hibernate.event.PreLoadEvent;
+import org.hibernate.event.PreLoadEventListener;
+import org.hibernate.event.PreUpdateEvent;
+import org.hibernate.event.PreUpdateEventListener;
+
+/**
+ * Contient l'ensemble de la partie listener et vetoable c'est à dire la gestion,
+ * les fires, ...
+ * 
+ * @author ruchaud
+ */
+public class TopiaFiresSupport {
+
+    static private Log log = LogFactory.getLog(TopiaFiresSupport.class);
+
+    /* Pour la transaction */
+    protected ListenerSet<TopiaTransactionListener> transactionListeners = new ListenerSet<TopiaTransactionListener>();
+    protected ListenerSet<TopiaTransactionVetoable> transactionVetoables = new ListenerSet<TopiaTransactionVetoable>();
+    protected TopiaTransactionEvent currentTransactionEvent;
+    
+    /* Pour les entités */
+    protected CategorisedListenerSet<TopiaEntityListener> entityListeners = new CategorisedListenerSet<TopiaEntityListener>();
+    protected CategorisedListenerSet<TopiaEntityVetoable> entityVetoables = new CategorisedListenerSet<TopiaEntityVetoable>();
+
+    /* Fires sur les transactions */
+    public void fireOnPreCommit(TopiaContextImplementor context) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostCommit");
+        }
+        try {
+            context.getFiresSupport().currentTransactionEvent = new TopiaTransactionEvent(context);
+            for(Iterator<TopiaTransactionVetoable> l=transactionVetoables.iterator(); l.hasNext();) {
+                l.next().beginTransaction(currentTransactionEvent);
+            }
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+
+    public void fireOnEntity(TopiaEntity entity) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnEntity");
+        }
+        currentTransactionEvent.addEntity(entity);
+    }
+    
+    public void fireOnPostCommit(TopiaContextImplementor context) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostCommit");
+        }
+        try {
+            for(Iterator<TopiaTransactionListener> l=transactionListeners.iterator(); l.hasNext();) {
+                l.next().commit(currentTransactionEvent);
+            }
+            currentTransactionEvent = new TopiaTransactionEvent(context);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostCommit", eee);
+            }
+
+        }
+    }
+    
+    public void fireOnPostRollback(TopiaContextImplementor context) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostRollback");
+        }
+        try {
+            for(Iterator<TopiaTransactionListener> l=transactionListeners.iterator(); l.hasNext();) {
+                l.next().rollback(currentTransactionEvent);
+            }
+            currentTransactionEvent = new TopiaTransactionEvent(context);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostRollback", eee);
+            }
+
+        }
+    }
+    
+    /* Fires sur les entités */
+    public void fireOnPreCreate(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPreCreate");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityVetoable> l=entityVetoables.iterator(entity.getClass()); l.hasNext();) {
+                l.next().create(event);
+            }
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+    
+    public void fireOnPostCreate(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostCreate");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityListener> l=entityListeners.iterator(entity.getClass()); l.hasNext();) {
+                l.next().create(event);
+            }
+            currentTransactionEvent.addEntity(entity);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostCreate for entity: " + entity, eee);
+            }
+        }
+    }
+    
+    public void fireOnPreLoad(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPreLoad");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityVetoable> l=entityVetoables.iterator(entity.getClass()); l.hasNext();) {
+                l.next().load(event);
+            }
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+    
+    public void fireOnPostLoad(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostLoad");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityListener> l=entityListeners.iterator(entity.getClass()); l.hasNext();) {
+                l.next().load(event);
+            }
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostLoad for entity: " + entity, eee);
+            }
+        }
+    }
+    
+    public void fireOnPreUpdate(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPreUpdate");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityVetoable> l=entityVetoables.iterator(entity.getClass()); l.hasNext();) {
+                l.next().update(event);
+            }
+            currentTransactionEvent.addEntity(entity);
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+    
+    public void fireOnPostUpdate(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostUpdate");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityListener> l=entityListeners.iterator(entity.getClass()); l.hasNext();) {
+                l.next().update(event);
+            }
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostUpdate for entity: " + entity, eee);
+            }
+        }
+    }
+    
+    public void fireOnPreDelete(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPreDelete");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityVetoable> l=entityVetoables.iterator(entity.getClass()); l.hasNext();) {
+                l.next().delete(event);
+            }
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+    
+    public void fireOnPostDelete(TopiaContextImplementor context, TopiaEntity entity, Object[] state) {
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostDelete");
+        }
+        try {
+            TopiaEntityEvent event = new TopiaEntityEvent(context, entity, state);
+            for(Iterator<TopiaEntityListener> l=entityListeners.iterator(entity.getClass()); l.hasNext();) {
+                l.next().delete(event);
+            }
+            currentTransactionEvent.addEntity(entity);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostDelete for entity: " + entity, eee);
+            }
+        }
+    }
+    
+    /* Fires sur les propriétés */
+    public void fireOnPreRead(VetoableChangeSupport vetoables,
+            TopiaEntity entity, String propertyName, Object value) {
+        
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPreRead");
+        }
+        try {
+            vetoables.fireVetoableChange(propertyName, value, value);
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+    
+    public void fireOnPostRead(PropertyChangeSupport listeners,
+            TopiaEntity entity, String propertyName, Object value) {
+        
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostRead");
+        }
+        try {
+            listeners.firePropertyChange(propertyName, value, value);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostRead", eee);
+            }
+        }
+
+    }
+    
+    public void fireOnPostRead(PropertyChangeSupport listeners,
+            TopiaEntity entity, String propertyName, int index, Object value) {
+        
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostRead");
+        }
+        try {
+            listeners.fireIndexedPropertyChange(propertyName, index, value, value);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostRead" , eee);
+            }
+        }
+
+    }
+    
+    public void fireOnPreWrite(VetoableChangeSupport vetoables,
+            TopiaEntity entity, String propertyName, Object oldValue, Object newValue) {
+        
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPreWrite");
+        }
+        try {
+            vetoables.fireVetoableChange(propertyName, oldValue, newValue);
+        } catch (Exception eee) {
+            throw new TopiaVetoException(eee);
+        }
+    }
+    
+    public void fireOnPostWrite(PropertyChangeSupport listeners,
+            TopiaEntity entity, String propertyName, Object oldValue, Object newValue) {
+        
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostWrite");
+        }
+        try {
+            listeners.firePropertyChange(propertyName, oldValue, newValue);
+            currentTransactionEvent.addEntity(entity);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostWrite", eee);
+            }
+        }
+    }
+    
+    public void fireOnPostWrite(PropertyChangeSupport listeners,
+            TopiaEntity entity, String propertyName, int index, Object oldValue, Object newValue) {
+        
+        if (log.isDebugEnabled()) {
+            log.debug("fireOnPostWrite");
+        }
+        try {
+            listeners.fireIndexedPropertyChange(propertyName, index, oldValue, newValue);
+            currentTransactionEvent.addEntity(entity);
+        } catch (Exception eee) {
+            if (log.isErrorEnabled()) {
+                log.error("Can't fireOnPostWrite", eee);
+            }
+        }
+    }
+    /**
+     * Object permettant de faire le lien entre les events hibernate et topia
+     * 
+     * @author poussin
+     */
+    static public class TopiaHibernateEvent implements
+                    PreInsertEventListener, PostInsertEventListener,
+                    PreLoadEventListener, PostLoadEventListener,
+                    PreUpdateEventListener, PostUpdateEventListener,
+                    PreDeleteEventListener, PostDeleteEventListener {
+
+        private static final long serialVersionUID = 7303593133642169218L;
+
+        protected TopiaContextImplementor rootContext;
+
+        public TopiaHibernateEvent(TopiaContextImplementor rootContext) {
+            this.rootContext = rootContext;
+        }
+
+        /**
+         * Recherche le context utilisant la session hibernate passe en
+         * parametre
+         * 
+         * @param hibernate la session hibernate que doit utiliser le
+         *        TopiaContext pour etre retourne
+         * @return le TopiaContext utilisant cette session hibernate ou null si
+         *         aucun TopiaContext n'utilise cette session.
+         */
+        protected TopiaContextImplementor getContext(
+                TopiaContextImplementor parent, Session hibernate) {
+            TopiaContextImplementor result = null;
+            for (TopiaContextImplementor context : parent.getChildContext()) {
+                try {
+                    if (context.getHibernate() == hibernate) {
+                        result = context;
+                    } else {
+                        result = getContext(context, hibernate);
+                    }
+                    if (result != null) {
+                        break;
+                    }
+                } catch (TopiaException eee) {
+                    if (log.isWarnEnabled()) {
+                        log.warn("Error durant la recherche d'un context pour"
+                                + " lancer un event", eee);
+                    }
+                }
+            }
+            return result;
+        }
+
+        private void attachContext(Object entity, TopiaContextImplementor context) {
+            if(entity instanceof TopiaEntityAbstract) {
+                TopiaEntityAbstract entityAbstract = (TopiaEntityAbstract) entity;
+                if(entityAbstract.getTopiaContext() == null) {
+                    try {
+                        entityAbstract.setTopiaContext(context);
+                    } catch (TopiaException eee) {
+                        if (log.isWarnEnabled()) {
+                            log.warn("Impossible d'initialiser le TopiaContext" +
+                                    " sur cette entité : " + entityAbstract, eee);
+                        }
+                    }
+                }
+            }
+        }
+
+        /* Création */
+        public boolean onPreInsert(PreInsertEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPreCreate(context, (TopiaEntity) event.getEntity(), event.getState());
+            }
+            return false;
+        }
+
+        public void onPostInsert(PostInsertEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPostCreate(context, (TopiaEntity) event.getEntity(), event.getState());
+            }
+        }
+
+        /* Chargement */
+        public void onPreLoad(PreLoadEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPreLoad(context, (TopiaEntity) event.getEntity(), event.getState());
+            }
+        }
+        
+        public void onPostLoad(PostLoadEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                attachContext(event.getEntity(), context);
+                context.getFiresSupport().fireOnPostLoad(context, (TopiaEntity) event.getEntity(), new Object[]{});
+            }
+        }
+
+        /* Modification */
+        public boolean onPreUpdate(PreUpdateEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPreUpdate(context, (TopiaEntity) event.getEntity(), event.getOldState());
+            }
+            return false;
+        }
+
+        public void onPostUpdate(PostUpdateEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPostUpdate(context, (TopiaEntity) event.getEntity(), event.getState());
+            }
+// FIXME indexation               if (!(entity instanceof NotIndexable) && context.isIndexEnabled()) {
+//                    context.getIndexEnginImplementor().recordForIndexation(id, event.getState());
+//                }
+            }
+        
+        /* Suppression */
+        public boolean onPreDelete(PreDeleteEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPreDelete(context, (TopiaEntity) event.getEntity(), event.getDeletedState());
+            }
+            return false;
+        }
+
+        public void onPostDelete(PostDeleteEvent event) {
+            TopiaContextImplementor context = getContext(rootContext, event.getSession());
+            if (context != null && event.getEntity() instanceof TopiaEntity) {
+                context.getFiresSupport().fireOnPostDelete(context, (TopiaEntity) event.getEntity(), event.getDeletedState());
+            }
+// FIXME indexation               if (!(entity instanceof NotIndexable) && context.isIndexEnabled()) {
+//                    context.getIndexEnginImplementor().recordForIndexation(id, null);
+//                }
+            }
+        }
+
+    /* Getters */
+    public CategorisedListenerSet<TopiaEntityListener> getEntityListeners() {
+        return entityListeners;
+    }
+
+    public CategorisedListenerSet<TopiaEntityVetoable> getEntityVetoables() {
+        return entityVetoables;
+    }
+
+    public ListenerSet<TopiaTransactionListener> getTransactionListeners() {
+        return transactionListeners;
+    }
+    
+    public ListenerSet<TopiaTransactionVetoable> getTransactionVetoable() {
+        return transactionVetoables;
+    }
+    
+    /* Adders */
+    public void addTopiaEntityListener(TopiaEntityListener listener) {
+        addTopiaEntityListener(TopiaEntity.class, listener);
+    }
+
+    public void addTopiaEntityListener(Class<TopiaEntity> entityClass, TopiaEntityListener listener) {
+        entityListeners.add(entityClass, listener);
+    }
+
+    public void addTopiaEntityVetoable(TopiaEntityVetoable vetoable) {
+        addTopiaEntityVetoable(TopiaEntity.class, vetoable);
+    }
+
+    public void addTopiaEntityVetoable(Class<TopiaEntity> entityClass, TopiaEntityVetoable vetoable) {
+        entityVetoables.add(entityClass, vetoable);
+    }
+
+    public void addTopiaTransactionListener(TopiaTransactionListener listener) {
+        transactionListeners.add(listener);
+    }
+
+    public void addTopiaTransactionVetoable(TopiaTransactionVetoable vetoable) {
+        transactionVetoables.add(vetoable);
+    }
+    
+    /* Removers */
+    public void removeTopiaEntityListener(TopiaEntityListener listener) {
+        removeTopiaEntityListener(TopiaEntity.class, listener);
+    }
+
+    public void removeTopiaEntityListener(Class<TopiaEntity> entityClass, TopiaEntityListener listener) {
+        entityListeners.remove(entityClass, listener);
+    }
+
+    public void removeTopiaEntityVetoable(TopiaEntityVetoable vetoable) {
+        removeTopiaEntityVetoable(TopiaEntity.class, vetoable);
+    }
+
+    public void removeTopiaEntityVetoable(Class<TopiaEntity> entityClass, TopiaEntityVetoable vetoable) {
+        entityVetoables.remove(entityClass, vetoable);
+    }
+
+    public void removeTopiaTransactionListener(TopiaTransactionListener listener) {
+        transactionListeners.remove(listener);
+    }
+
+    public void removeTopiaTransactionVetoable(TopiaTransactionVetoable vetoable) {
+        transactionVetoables.remove(vetoable);
+    }
+
+}