//itemController.init();
        //console.log("Model for item " + i + ":", listModel.getItemModel(i));
        itemController.setModel(listModel.getItemModel(i));
        itemController.setListID(this.listID);
        itemController.setListItemID(this.nextItemID);
        itemController.setListModel(listModel);
        this.nextItemID++;
        itemController.createElement(this.containerElement);
        itemController.drawed();
        this.itemControllers[i] = itemController;
        this.informListeners('listItemControllerAdded',[this,
                                                        itemController,
                                                        i]);
    }

    itemController.setListItemID(this.nextItemID);
    this.nextItemID++;
    var nextController = this.itemControllers[index];
    if(nextController) {
        var nextElement = nextController.getElement();
        /*console.log("insertBeforeEvent - nextController.getElement:");
         console.log(nextElement);*/
        itemController.createElement(this.containerElement, nextElement);
        this.itemControllers.splice(index, 0, itemController);
    }
    else {
        /*console.log(this.containerElement);*/
        itemController.createElement(this.containerElement);
        this.itemControllers.push(itemController);
    }

    itemController.setListModel(this.model);
    itemController.drawed();

    this.informListeners('listItemControllerAdded',[this,

/**
 * @private
 */
ListItemController._refreshTextProperties = function() {
    for (var key in this.textProperties) {

        if (this.textProperties[key] != undefined) {
            //console.log("found property: " + key);
            //var elementID = this.textProperties[key] + "_#n";
            var elementID = this.generateElementID(this.textProperties[key]);

            //console.log(elementID);
            var textContainer = document.getElementById(elementID);
            if (textContainer != null) {
                emptyElement(textContainer);
                var text = this.model.getProperty(key);

                textContainer.appendChild(document.createTextNode(text));
            }
        }
    }
};

/**

/**
 * @private
 */
ListItemController._refreshAttributesProperties = function() {
    for (var key in this.attrProperties) {
        if (this.attrProperties[key] != undefined) {

            var data = this.attrProperties[key];

            //console.log(data);
            var elementID = this.generateElementID(data["idPrefix"]);

            var element = document.getElementById(elementID);
            if (element != null) {
                var value = this.model.getProperty(key);
                element.setAttribute(data["attribute"], value);
            }
        }
    }
};

/**
 * @private
 */
ListItemController._refreshMapAttributes = function() {
    for (var key in this.attrMaps) {
        var data = this.attrMaps[key];
        if (this.model.hasProperty(key)) {
            var elementID = this.generateElementID(data["idPrefix"]);

            var element = document.getElementById(elementID);

            if (element != undefined) {
                var map = data["propertyMap"];
                var value = this.model.getProperty(key);
                var mappedValue = map[value];
                if (mappedValue != undefined) {

        this.refresh();
    }
};


/**
 * Create the actual HTML element that will match this list item, including
 * the content from the model set up earlier. This is mostly intended to be
 * called by a ListController.
 *

 * 'containerElement' is the element that the newly created element will be 
 *                    appended to.
 * If 'beforeElement' is defined, the new element should be created right
 * before it, but as a child of 'containerElement'.
 */

ListItemController.createElement = function(containerElement,

                                            beforeElement) {

    this.IDPrefix = "ListItemController" + this.getListID() + ".";
    var newNode = cloneNodeSetIDs(this.itemTemplate,
                                  this.IDPrefix,
                                  this.getListItemID());




    if (beforeElement == undefined) {
        containerElement.appendChild(newNode);
    } else {
        containerElement.insertBefore(newNode, beforeElement);
    }

    this.myElement = newNode;

    if (this.model !== undefined) {
        this.refresh();
    }







    //console.log("createNewElement done");
};


/**
 * Return the element from within the containing element of this list item

 * (sectioned lists).
 *
 * @class StorkUtil.ListOfListsItem
 * @extends StorkUtil.ListItemController
 * @singleton
 *****************************************************************************/
var ListOfListsItem = clone(ListItemController);

ListOfListsItem.renderIfEmpty = true;


/**
 * @property subListController
 */
ListOfListsItem.clonedProperty("subListController", ListController);


ListOfListsItem.deleted = function() {
    this.superMethod(ListOfListsItem.deleted, "deleted");

    if (this.model && this.sublistModelProperty) {
        subListModel = this.model.getProperty(this.subListModelProperty);
        sublistModel.removeListener(this);
    }
    return;
};

    
/**
 * Get the ListController for the sub-list within this item.
 * This ListController is automatically created when a ListOfListItem is
 * cloned.
 */
ListOfListsItem.getSubListController = function() {
    return this.subListController;

 * ListModel object as its value, and which will be used to populate the
 * sub-list
 */
ListOfListsItem.setSubListModelProperty = function(propertyName) {
    this.subListModelProperty = propertyName;
};


/**
 * Override ListItemController refresh() to implement functionality of
 * renderIfEmpty().
 */

ListOfListsItem.refresh = function() {    
    if (! this.renderIfEmpty) {
        var sublistModel = this.getSubListController().getModel();

        if (!sublistModel || (sublistModel.getLength() == 0)) {
            hideElement(this.myElement);
        } else {
            showElement(this.myElement);
        }                
    }
        
    this.superMethod(ListOfListsItem.refresh, "refresh");
};


/**
 * Override the normal ListItemController createElement() with one that
 * builds the sub-list.
 */
ListOfListsItem.createElement = function(containerElement,
                                         beforeElement) {
    var subListModel;
    var listContainer;

    //console.debug("ListOfListsItem - createElement");
    this.superMethod(ListOfListsItem.createElement, "createElement", 
                     containerElement, beforeElement);

    listContainer = this.getContainedElement(this.subListContainer);
    this.subListController.setListContainer(listContainer);

    subListModel = this.model.getProperty(this.subListModelProperty);
    this.subListController.setModel(subListModel);
    subListModel.addListener(this);
};


ListOfListsItem.renderIfEmpty = function(render) {
    this.renderIfEmpty = render;
    return;
};


/* If the underlining list changes, refresh this item. The item may need to 
   change its appearance based on changes in the sublist */

ListOfListsItem.insertBeforeEvent = function(list, item, index) {
    this.refresh();
};

ListOfListsItem.deleteItemEvent = function(list, item, index) {
    this.refresh();
};

ListOfListsItem.resetEvent = function(list) {
    this.refresh();
};

//***********************************************************
// * Model for lists
//**********************************************************/

/**
 * Model for lists
 *
 * Events thrown: 
 * insertBeforeEvent  (newItem, index)
 * deleteItemEvent (item, index)
 * resetEvent
 */
var ListModel = clone(StorkModel);

/**
 * @property {Array} items
 */
ListModel.copiedProperty("items", []);

 * ListModel, the item deleted, and the index of the item deleted.
 */
ListModel.deleteIndex = function(index) {
    var i, item;

    item = this.items[index];
    this.items.splice(index, 1);
    this.informListeners("deleteItemEvent", [this, item, index]);
    /*
    for (i=0; i < this.listeners.length; i++) {
        if (this.listeners[i].deleteItemEvent != undefined) {
            this.listeners[i].deleteItemEvent(this, item, index);
        }
    }*/
};


/**
 * Insert a list item model object, based on 'object',
 * before the one specified in 'index'.
 *
 * @param {Object} object is any Javascript object. Each property of it will 
 *      be made into a StorkModel property.
 *
 *      Calls insertBeforeEvent(sourceModel, model, index) for each listener,
 *      where 'sourceModel' is this ListModel, 'model' is the added model and

 *      'index' is the index where it now resides.
 *
 * @return {StorkCore.StorkModel}
 */

ListModel.insertObjectBefore = function(object, index) {
    var model = StorkModel.createFromObject(object);
    this.items.splice(index, 0, model);

 *          listener, where 'sourceModel' is this ListModel, 'model' is the
 *          added model
 */

ListModel.push = function(storkModel) {
    this.items.push(storkModel);
    this.informListeners("insertBeforeEvent",
                         [this, storkModel, this.items.length]);
    return;
};


/**
 * Insert a list item model object, based on 'object' to end of list.
 *

    }

    return items;
};


/**
 * Get the item model for the given 'index' (an index into the item list).
 */
ListModel.getItemModel = function(index) {
    return this.items[index];
};

/** ***********************************************************************
 * implements a list with filtering of its items
 **************************************************************************/
var FilteredListModel = clone(ListModel);

    return model;
};

//override
FilteredListModel._pushObject = function(model) {
    this.items.push(model);
    this.informListeners("insertBeforeEvent",
                         [this, model, this.items.length]);
    return model;
};

FilteredListModel._deleteIndex = FilteredListModel.deleteIndex;

FilteredListModel.throwReadOnlyError = function(){
    throw Error("Method not available in read only FilteredListModel instance");