public final void handleEvent(final Event event) {

	// get the current table item
	TableItem tableItem = (TableItem) event.item;
	// get the index
	int index = event.index;


	// now get the next element from the dao
	T nextElement = ((ILazyLoadingDAO<T>) getDao()).next();
	// add the element to the list model
	WritableList model = getWritableListDataModel( false );
	if( ! model.contains( nextElement ) )
	    model.add( nextElement );

	// set the table item in the table
	tableItem.setData( nextElement );
	        
	
       
    }

    public synchronized final T next() {
	// if the queue is empty I need to fetch new elements
	if( this.cache.isEmpty() )
	    // execute the query
	    this.loadChunckOfData();
	
	// the queue contains at least an element already cached, so
	// return it
	return this.cache.remove();
    }

    public synchronized final List<T> loadChunckOfData(){



	// execute the query to retrieve a new chunk of data
	List<T> fetchedElements = jdbcTemplate.query( getLazyLoadingQuery(), 
		new Object[]{ currentOffset, fetchTreshold }, 
		rowMapper  );


	// if no fetched elements it is time to stop the lazy loading (i.e., reset the offset so that
	// the next loading will start again from the beginning of the table)
	if( fetchedElements == null  || fetchedElements.isEmpty() ){
	    currentOffset = 0;
	}
	else{
	    // if here a chunk of data has been loaded from the database, so I need
	    // to move forward the offset and to refresh each element of the list

	    // increment the offset for the next query
	    currentOffset += fetchTreshold;

	    // create a temporary list
	    List<T> refreshedElements = new LinkedList<T>();

	    // refresh all the loaded elements
	    for( T currentElement : fetchedElements )
		refreshedElements.add( refresh(currentElement) );

	    // switch the lists
	    fetchedElements = refreshedElements;
	}

	// cache the returned chunk of data
	cache.addAll(fetchedElements);

	return fetchedElements;
    }