Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.jsystems.framework.tree
Class BusinessTreeModel

    java.lang.Object
      de.jsystems.framework.common.BusinessModel
          de.jsystems.framework.tree.BusinessTreeModel

All Implemented Interfaces:
  IBusinessModelSave, IBusinessTreeModel, Serializable, TreeModel

public class BusinessTreeModel
extends BusinessModel
implements IBusinessTreeModel, Serializable

Model fuer den `BusinessTree`. In diesem Model werden die Daten fuer den Baum als `TreeItem`-Objekte verwaltet. Die Standardschnittstelle fuer Treemodelle (`TreeModel`) wird von dieser Implementierung unterstuetzt. Damit kann das Model auch an einem ganz normalen `JTree` benutzt werden. Zusaetzlich wird die Schnittstelle `BusinessModel` unterstuetzt, womit die Klasse auch die Erzeugung der verwalteten Items uebernehmen kann.

Version:
  1.0
  Copyright by Jens Homm 2001 - 2003
Author:
  Jens Homm JSYSTEMS
See Also:
  Serialized Form

Field Summary
`protected boolean` | `askAllowsChildren` Sind Knoten mit Kindeintraegen erlaubt.
`protected EventListenerList` | `listenerList` Liste der EventListener.
`protected TreeItem` | `root` Wurzelitem des Baumes.

Fields inherited from class de.jsystems.framework.common.BusinessModel
`DIALOG_ABBRUCH, DIALOG_OK, file, filename, itemclass, itemList, OPEN_DIALOG, pathname, SAVE_DIALOG, saver`

Constructor Summary
`BusinessTreeModel(Class itemClass, TreeItem root)` Erzeugt ein neues Model für einen Baum.
`BusinessTreeModel(Class itemClass, TreeItem root, boolean askAllowsChildren)` Erzeugt einen Baum, bei dem festgelegt ist, ob ein Eintrag selbst weitere Einträge enthalten darf oder nicht.

Method Summary
`void` | `addItem(Item item)` Ueber diese Methode kann dem Model(bzw. dem Baum) kein neuer Eintrag hinzugefuegt werden.
`void` | `addTreeModelListener(TreeModelListener listener)` Fügt der Liste der registrierten Listener einen neuen Listener hinzu.
`boolean` | `askAllowsChildren()` Gibt zurück ob Blattknoten unterstützt werden.
`Item` | `createNewItem()` Items fuer einen Baum koennen nur ueber die Methoden `createNewItem(String)` `createNewItem(String, boolean)` `createNewItem(String, Object)` `createNewItem(String, Object, boolean)` erzeugt werden.
`Item` | `createNewItem(String name)` Erzeugt ein neues Item für den Baum.
`Item` | `createNewItem(String name, boolean askAllowChildren)` Erzeugt ein neues Item für den Baum.
`Item` | `createNewItem(String name, Object userObject)` Erzeugt ein neues Item für den Baum.
`Item` | `createNewItem(String name, Object userObject, boolean askAllowChildren)` Erzeugt ein neues Item für den Baum.
`Item` | `createNewItem(String name, String itemId)` Erzeugt ein neues Item für den Baum.
`protected void` | `fireTreeNodesChanged(Object source, Object[] path, int[] childIndices, Object[] children)` Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben.
`protected void` | `fireTreeNodesInserted(Object source, Object[] path, int[] childIndices, Object[] children)` Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben.
`protected void` | `fireTreeNodesRemoved(Object source, Object[] path, int[] childIndices, Object[] children)` Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben.
`protected void` | `fireTreeStructureChanged(Object source, Object[] path, int[] childIndices, Object[] children)` Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben.
`Object` | `getChild(Object parent, int index)` Gibt das Child-Element im Parent-Knoten am spezifizierten Index zurück.
`int` | `getChildCount(Object parent)` Gibt die Anzahl enthaltener Kindknoten des parent-Objektes zurück.
`int` | `getIndexOfChild(Object parent, Object child)` Gibt den Index des Items `child` im Item `parent` zurück.
`Item` | `getItem(int index)` Da die Items in einem Baum keine einfache Listenstruktur darstellen, kann ueber diese Methode kein Item aus dem Model gelesen werden.
`ComboBoxModel` | `getItemComboBox()` Aus dem Baummodel kann kein ComboBoxModel erzeugt werden.
`int` | `getItemCount()` Gibt die Anzahl der Items in diesem Model zurück.
`ListModel` | `getItemListBox()` Aus dem Baummodel kann kein ListModel erzeugt werden.
`EventListener[]` | `getListeners(Class listenerType)` Gibt ein Array mit allen Listenern des spezifizierten Typs zurück, die sich an diesem Model registriert haben.
`TreeNode[]` | `getPathToRoot(TreeNode node)` Füllt ein Array mit allen Knoten bis zum `root`-Knoten.
`protected TreeNode[]` | `getPathToRoot(TreeNode node, int depth)` Füllt ein Array mit allen Knoten bis zum `root`-Knoten.
`Object` | `getRoot()` Gibt den aktuellen Root-Knoten zurück.
`Item` | `getSaveItem(int index)` Holt das zu speichernde Item aus dem Model.
`int` | `getSaveItemCount()` Holt die Anzahl zu speichernder Items aus dem Model.
`void` | `insertNode(MutableTreeNode newChild)` Fuegt den uebergebenen Knoten dem Rootknoten des Baumes hinzu.
`void` | `insertNodeInto(MutableTreeNode newChild, MutableTreeNode parent)` Fügt einem Knoten im Baum einen neuen Eintrag hinzu.
`void` | `insertNodeInto(MutableTreeNode newChild, MutableTreeNode parent, int index)` Fügt einem Knoten im Baum einen neuen Eintrag hinzu.
`boolean` | `isLeaf(Object node)` Gibt true zurück, wenn es sich bei dem übergebenen Element um ein Blatt im Baum handelt.
`boolean` | `isRoot(TreeItem item)` Prüft, ob das übergebene TreeItem der Root-Knoten dieses Baumes ist.
`void` | `loadItem(Item item)` Das übergebene Item wird im Model wieder gespeichert.
`void` | `nodeChanged(TreeNode node)` Diese Methode sollte aufgerufen werden, nachdem sich ein Knoten im Baum geändert hat.
`void` | `nodesChanged(TreeNode node, int[] childIndices)` Diese Methode sollte nach jeder Änderung an Baumeinträgen aufgerufen werden.
`void` | `nodeStructureChanged(TreeNode node)` Wenn sich viel an der Struktur des Baumes geändert hat, sollte diese Methode aufgerufen werden.
`void` | `nodesWereInserted(TreeNode node, int[] childIndices)` Nach dem hinzufügen von neuen Baumelementen sollte diese Methode aufgerufen werden.
`void` | `nodesWereRemoved(TreeNode node, int[] childIndices, Object[] removedChildren)` Nach dem löschen von Einträgen aus dem Baum sollte diese Methode aufgerufen werden.
`void` | `preLoad()` Aus dem Model werden vor dem neu Laden alle Items gelöscht.
`void` | `reload()` Diese Methode sollte aufgerufen werden, wenn die Struktur des Baumes geändert wurde.
`void` | `reload(TreeNode node)` Nach Änderungen in der Baumstruktur sollte diese Methode aufgerufen werden.
`void` | `removeAllItems()` Das loeschen aller Items aus einem TreeModel ist nicht moeglich, da immer zumindest der Root-Knoten vorhandensein muss.
`void` | `removeItem(Item item)` Items koennen nicht direkt aus dem Model geloescht werden.
`void` | `removeNodeFromParent(MutableTreeNode node)` Löscht den übergebenen Eintrag aus dem Baum.
`void` | `removeTreeModelListener(TreeModelListener listener)` Löscht den übergebenen Listener aus der Liste der registrierten Listener.
`void` | `setAskAllowsChildren(boolean askAllowsChildren)` Legt fest, ob Einträge generell wiederum Einträge enthalten dürfen oder nicht.
`void` | `setRoot(TreeItem root)` Setzt einen neuen Root-Knoten für den Baum.
`void` | `updateItem(Item item)` Items koennen in einem Tree nicht ueber diese Methode geaendert werden.
`void` | `valueForPathChanged(TreePath path, Object value)` Setzt das UserObject für einen Baumeintrag.

Methods inherited from class de.jsystems.framework.common.BusinessModel
`load, save_as, save, setSaver, showFileDialogBox`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### root

    protected TreeItem root

  Wurzelitem des Baumes.

### listenerList

    protected EventListenerList listenerList

  Liste der EventListener.

### askAllowsChildren

    protected boolean askAllowsChildren

  Sind Knoten mit Kindeintraegen erlaubt.

Constructor Detail

### BusinessTreeModel

    public BusinessTreeModel(Class itemClass,
                             TreeItem root)

  Erzeugt ein neues Model für einen Baum. Dabei darf jedes Item wiederum Kinder haben. Das uebergebene Item stellt die Wurzel des Baumes dar. Wenn hier `NULL` übergeben wird, wird eine `IllegalArgumentException` ausgelöst. Der Typ des Items und der Typ der uebergebenen Klasse muessen gleich sein.

Parameters:
  `itemClass` - Der Typ der Items die von diesem Model verwaltet werden sollen.
  `root` - Ein TreeItem, das gleichzeitig die Wurzel des Baumes ist.

### BusinessTreeModel

    public BusinessTreeModel(Class itemClass,
                             TreeItem root,
                             boolean askAllowsChildren)

  Erzeugt einen Baum, bei dem festgelegt ist, ob ein Eintrag selbst weitere Einträge enthalten darf oder nicht. Wenn hier `NULL` übergeben wird, wird eine `IllegalArgumentException` ausgelöst. Der Typ des Items und der Typ der uebergebenen Klasse muessen gleich sein.

Parameters:
  `itemClass` - Der Typ der Items die von diesem Model verwaltet werden sollen.
  `root` - Ein TreeItem, das gleichzeitig die Wurzel des Baumes ist.
  `askAllowsChildren` - Mit diesem boolschen Wert wird festgelegt, ob ein Eintrag selbst wiederum Einträge enthalten darf. Wird `false` übergeben, darf jeder Eintrag selbst wiederum Einträge enthalten. Ansonsten wird das Item selbst gefragt, ob es Kindeinträge enthalten kann.
See Also:
  `TreeItem.allowsChildren`

Method Detail

### setAskAllowsChildren

    public void setAskAllowsChildren(boolean askAllowsChildren)

  Legt fest, ob Einträge generell wiederum Einträge enthalten dürfen oder nicht. Ob es sich bei einem Knoten um einen Blattknoten handelt oder nicht, wird über die Methoden `TreeItem.getAllowsChildren()` oder `TreeItem.isLeaf()` des TreeItems abgefragt. Wenn hier `true` uebergeben wird, wird die Methode `askAllowsChildren()` aufgerufen, ansonsten `isLeaf(Object)`.

  Parameters:
    `askAllowsChildren` - Mit diesem boolschen Wert wird gestgelegt, ob ein Eintrag selbst wiederum Einträge enthalten darf. Wird false übergeben, darf jeder Eintrag selbst wiederum Einträge enthalten. Ansonsten wird das Item selbst gefragt, ob es Kindeinträge enthalten kann.
  See Also:
    `TreeItem.allowsChildren`

### askAllowsChildren

    public boolean askAllowsChildren()

  Gibt zurück ob Blattknoten unterstützt werden.

  Returns:
    true, wenn nur Knoten, die keine weiteren Kinder erlauben Blattknoten sind, false, wenn Knoten die keine Kinder enthalten(auch wenn sie können) Blattknoten sind.

### setRoot

    public void setRoot(TreeItem root)

  Setzt einen neuen Root-Knoten für den Baum. Wenn hier `null` übergeben wird, wird eine `IllegalArgumentException` ausgelöst. Alle registrierten Listener werden benachrichtigt, das sich die Struktur des Baumes geaendert hat.

  Parameters:
    `root` - Der neue Root-Knoten fuer den Baum.

### getRoot

    public Object getRoot()

  Gibt den aktuellen Root-Knoten zurück.

  Specified by:
    `getRoot` in interface `TreeModel`
  Returns:
    der Root-Knoten des baumes.

### isRoot

    public boolean isRoot(TreeItem item)

  Prüft, ob das übergebene TreeItem der Root-Knoten dieses Baumes ist.

  Parameters:
    `item` - Der zu prüfende Knoten.
  Returns:
    `true`, wenn der übergebene Knoten die gleiche ID hat wie der Root-Knoten.

### getIndexOfChild

    public int getIndexOfChild(Object parent,
                               Object child)

  Gibt den Index des Items `child` im Item `parent` zurück. Wenn die beiden Parameter nicht vom Typ `TreeItem` sind, wird eine `IllegalArgumentException` ausgeloest.

  Specified by:
    `getIndexOfChild` in interface `TreeModel`
  Parameters:
    `parent` - Das Knotenobjekt, in dem der Index des child-Objektes gesucht wird.
    `child` - Das child-Objekt, dessen Index im parent-Objekt gesucht wird.
  Returns:
    Den Index des child-Objektes oder -1, wenn entweder einer der Parameter `null` ist oder der Child-Knoten kein child des Parent-Knotens ist.

### getChild

    public Object getChild(Object parent,
                           int index)

  Gibt das Child-Element im Parent-Knoten am spezifizierten Index zurück. Wenn das uebergebene Parent-Objekt nicht vom Typ `TreeItem` ist, wird eine `IllegalArgumentException` ausgeloest.

  Specified by:
    `getChild` in interface `TreeModel`
  Parameters:
    `parent` - Ein Knoten im Baum.
    `index` - Index für ein Child-Element im Knoten.
  Returns:
    Das Child-Element am Index `index` im Knoten `parent`.

### getChildCount

    public int getChildCount(Object parent)

  Gibt die Anzahl enthaltener Kindknoten des parent-Objektes zurück. Wenn es sich bei parent um ein Blatt handelt oder dieses Element keine Kindelemente enthält, wird 0 zurückgegeben. Wenn das uebergebene Parent-Objekt nicht vom Typ `TreeItem` ist, wird eine `IllegalArgumentException` ausgeloest.

  Specified by:
    `getChildCount` in interface `TreeModel`
  Parameters:
    `parent` - Ein Knoten im Baum.
  Returns:
    Anzahl Kindelemente im uebergebenen Parent-Objekt.

### isLeaf

    public boolean isLeaf(Object node)

  Gibt true zurück, wenn es sich bei dem übergebenen Element um ein Blatt im Baum handelt. Festgestellt wird dies in Abhängigkeit des Schalters `askAllowsChildren` im TreeItem bzw. im Model. Wenn das uebergebene Parent-Objekt nicht vom Typ `TreeItem` ist, wird eine `IllegalArgumentException` ausgeloest.

  Specified by:
    `isLeaf` in interface `TreeModel`
  Parameters:
    `node` - Der zu prüfende Baumeintrag.
  Returns:
    true, wenn es sich bei diesem Eintrag um ein Blatt handelt.
  See Also:
    `askAllowsChildren`, `TreeModel.isLeaf(java.lang.Object)`

### reload

    public void reload()

  Diese Methode sollte aufgerufen werden, wenn die Struktur des Baumes geändert wurde. Hierbei werden dann alle registrierten Listener benachrichtigt, daß sich das Model geändert hat.

### valueForPathChanged

    public void valueForPathChanged(TreePath path,
                                    Object value)

  Setzt das UserObject für einen Baumeintrag. Der Baumeintrag wird duch den übergebenen Pfad spezifiziert. Der Pfad geht dabei vom Root-Knoten aus. Die Objekte im Pfad muessen vom Typ `TreeItem` sein.

  Specified by:
    `valueForPathChanged` in interface `TreeModel`
  Parameters:
    `path` - Pfad zu dem Baumeintrag, dessen UserObject geändert werden soll.
    `value` - Das neue UserObject für den Baumeintrag.

### insertNode

    public void insertNode(MutableTreeNode newChild)

  Fuegt den uebergebenen Knoten dem Rootknoten des Baumes hinzu. Der uebergebene Knoten muss dabei vom Typ `TreeItem` sein.

  Parameters:
    `newChild` - Der dem Rootknoten hinzuzufuegende Knoten.

### insertNodeInto

    public void insertNodeInto(MutableTreeNode newChild,
                               MutableTreeNode parent)

  Fügt einem Knoten im Baum einen neuen Eintrag hinzu. Der neue Knoten wird am Ende eingefügt. Die beiden uebergebenen Objekte muessen dabei vom Typ `TreeItem` sein.

  Parameters:
    `newChild` - Ein neuer Eintrag im Baum.
    `parent` - Der Knoten im Baum, der einen neuen Eintrag erhält.

### insertNodeInto

    public void insertNodeInto(MutableTreeNode newChild,
                               MutableTreeNode parent,
                               int index)

  Fügt einem Knoten im Baum einen neuen Eintrag hinzu. Der neue Knoten wird am `index` eingefügt. Nach dem hinzufügen werden alle registrierten Listener benachrichtigt. Die beiden uebergebenen Objekte muessen dabei vom Typ `TreeItem` sein.

  Parameters:
    `newChild` - Ein neuer Eintrag im Baum.
    `parent` - Der Knoten im Baum, der einen neuen Eintrag erhält.
    `index` - Index im Parentobjekt, an dem der neue Eintrag stehen soll.

### removeNodeFromParent

    public void removeNodeFromParent(MutableTreeNode node)

  Löscht den übergebenen Eintrag aus dem Baum. Nach dem löschen werden alle registrierten Listener benachrichtigt. Der Root-Knoten kann nie geloescht werden. Wenn dieser hier uebergeben wird, wird eine `IllegalArgumentException` ausgeloest. Ebenso wird eine `IllegalArgumentException` ausgeloest wenn der uebergebene Knoten kein Elterobjekt hat. Das kann eigentlich auch nur beim Root-Knoten der Fall sein. Der uebergebene Knoten muss vom Typ `TreeItem` sein.

  Parameters:
    `node` - Der zu löschende Eintrag im Baum.

### nodeChanged

    public void nodeChanged(TreeNode node)

  Diese Methode sollte aufgerufen werden, nachdem sich ein Knoten im Baum geändert hat. Damit werden dann alle Listener benachrichtigt, das sich der Baum geaendert hat.

  Parameters:
    `node` - Der geänderte Knoten im Baum.

### reload

    public void reload(TreeNode node)

  Nach Änderungen in der Baumstruktur sollte diese Methode aufgerufen werden. Übergeben wird dabei der Knoten im Baum, ab dem sich die Struktur geändert hat. Alle registrierten Listener werden benachrichtigt.

  Parameters:
    `node` - Der Knoten, ab dem sich die Baumstruktur geändert hat.

### nodesWereInserted

    public void nodesWereInserted(TreeNode node,
                                  int[] childIndices)

  Nach dem hinzufügen von neuen Baumelementen sollte diese Methode aufgerufen werden. `childIndices` enthält alle Indizes der hinzugefügten Elemente. Diese müssen in aufsteigender Reihenfolge im Array sortiert sein. `node` ist der Knoten, der neue Elemente erhalten hat.

  Parameters:
    `node` - Der Knoten, der neue Elemente erhalten hat.
    `childIndices` - Enthält alle Indizes der hinzugefügten Elemente. Diese müssen in aufsteigender Reihenfolge im Array sortiert sein.

### nodesWereRemoved

    public void nodesWereRemoved(TreeNode node,
                                 int[] childIndices,
                                 Object[] removedChildren)

  Nach dem löschen von Einträgen aus dem Baum sollte diese Methode aufgerufen werden. `childIndices` enthält die Indizes der gelöschten Elemente und muß aufsteigend sortiert sein. `removedChildren` ist ein Array mit den gelöschten Baumeinträgen.

  Parameters:
    `node` - Der Elternknoten, aus dem Elemente gelöscht wurden.
    `childIndices` - Enthält die Indizes der gelöschten Elemente und muß aufsteigend sortiert sein.
    `removedChildren` - Ein Array mit den gelöschten Baumeinträgen.

### nodesChanged

    public void nodesChanged(TreeNode node,
                             int[] childIndices)

  Diese Methode sollte nach jeder Änderung an Baumeinträgen aufgerufen werden. Damit werden dann alle registrierten Listener ueber die Aenderung im Baum informiert.

  Parameters:
    `node` - Der Elternknoten, dessen Kindknoten sich geändert haben.
    `childIndices` - Ein Array mit allen Indizes der geänderten Kindeinträge zu dem Knoten `node`.

### nodeStructureChanged

    public void nodeStructureChanged(TreeNode node)

  Wenn sich viel an der Struktur des Baumes geändert hat, sollte diese Methode aufgerufen werden. Es wird ein `TreeStructureChanged`-Event ausgelöst.

  Parameters:
    `node` - Der Knoten, dessen Struktur sich geändert hat.

### getPathToRoot

    public TreeNode[] getPathToRoot(TreeNode node)

  Füllt ein Array mit allen Knoten bis zum `root`-Knoten. Dabei ist der übergebene Knoten der letzte im Array. Der erste ist der Root-Knoten des Baumes. Die Länge des Arrays entspricht der Tiefe des übergebenen Knoten im Baum.

  Parameters:
    `node` - Knoten im Baum, dessen Pfad zum Rootknoten ermittelt werden soll.
  Returns:
    Ein Array mit allen Knoten bis zum `root`-Knoten. Dabei ist der übergebene Knoten der letzte im Array. Der erste ist der Root-Knoten des Baumes.

### getPathToRoot

    protected TreeNode[] getPathToRoot(TreeNode node,
                                       int depth)

  Füllt ein Array mit allen Knoten bis zum `root`-Knoten. Dabei ist der übergebene Knoten der letzte im Array. Der erste ist der Root-Knoten des Baumes. Die Länge des Arrays entspricht der Tiefe des übergebenen Knoten im Baum. Die Methode wird dabei rekursiv aufgerufen, bis der Root-Eintrag des Baumes gefunden wurde. Dann ist die Länge des Pfades bekannt und es kann ein Array in der gewünschten Größe erzeugt werden. Beim zurücklaufen der Rekursion wird dieses Array dann gefüllt.

  Parameters:
    `node` - Der Knoten im Baum, dessen Pfad zum Rootknoten ermittelt werden soll.
    `depth` - Ein Zähler mit der aktuellen Tiefe des Eintrages. Dieser Zähler wird bei der Rekusion hochgesetzt.
  Returns:
    Ein Array mit allen Knoten bis zum `root`-Knoten. Dabei ist der übergebene Knoten der letzte im Array. Der erste ist der Root-Knoten des Baumes.

### addTreeModelListener

    public void addTreeModelListener(TreeModelListener listener)

  Fügt der Liste der registrierten Listener einen neuen Listener hinzu.

  Specified by:
    `addTreeModelListener` in interface `TreeModel`
  Parameters:
    `listener` - Der hinzuzufügende Listener.

### removeTreeModelListener

    public void removeTreeModelListener(TreeModelListener listener)

  Löscht den übergebenen Listener aus der Liste der registrierten Listener.

  Specified by:
    `removeTreeModelListener` in interface `TreeModel`
  Parameters:
    `listener` - Der zu löschende Listener.

### fireTreeNodesChanged

    protected void fireTreeNodesChanged(Object source,
                                        Object[] path,
                                        int[] childIndices,
                                        Object[] children)

  Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben. Das Event-Objekt wird mit den übergebenen Parametern instanziiert.

  Parameters:
    `source` - Die Stelle, an der das Event ausgelöst wurde.
    `path` - Der Pfad des Knotens im Baum, an dem sich was geändert hat.
    `childIndices` - Ein Array mit Indizes von Einträgen, die sich geändert haben. Die Indizes beziehen sich dabei auf das Elternobjekt, das mit dem übergebenem Pfad spezifiziert wurde.
    `children` - Ein Array mit Elementen, an denen sich was geändert hat.

### fireTreeNodesInserted

    protected void fireTreeNodesInserted(Object source,
                                         Object[] path,
                                         int[] childIndices,
                                         Object[] children)

  Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben. Das Event-Objekt wird mit den übergebenen Parametern instanziiert.

  Parameters:
    `source` - Die Stelle, an der das Event ausgelöst wurde.
    `path` - Der Pfad des Knotens im Baum, an dem sich was geändert hat.
    `childIndices` - Ein Array mit Indizes von Einträgen, die sich geändert haben. Die Indizes beziehen sich dabei auf das Elternobjekt, das mit dem übergebenem Pfad spezifiziert wurde.
    `children` - Ein Array mit Elementen, an denen sich was geändert hat.

### fireTreeNodesRemoved

    protected void fireTreeNodesRemoved(Object source,
                                        Object[] path,
                                        int[] childIndices,
                                        Object[] children)

  Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben. Das Event-Objekt wird mit den übergebenen Parametern instanziiert.

  Parameters:
    `source` - Die Stelle, an der das Event ausgelöst wurde.
    `path` - Der Pfad des Knotens im Baum, an dem sich was geändert hat.
    `childIndices` - Ein Array mit Indizes von Einträgen, die sich geändert haben. Die Indizes beziehen sich dabei auf das Elternobjekt, das mit dem übergebenem Pfad spezifiziert wurde.
    `children` - Ein Array mit Elementen, an denen sich was geändert hat.

### fireTreeStructureChanged

    protected void fireTreeStructureChanged(Object source,
                                            Object[] path,
                                            int[] childIndices,
                                            Object[] children)

  Feuert einen Event an alle registrierten Listener, die sich für diese Art von Event registriert haben. Das Event-Objekt wird mit den übergebenen Parametern instanziiert.

  Parameters:
    `source` - Die Stelle, an der das Event ausgelöst wurde.
    `path` - Der Pfad des Knotens im Baum, an dem sich was geändert hat.
    `childIndices` - Ein Array mit Indizes von Einträgen, die sich geändert haben. Die Indizes beziehen sich dabei auf das Elternobjekt, das mit dem übergebenem Pfad spezifiziert wurde.
    `children` - Ein Array mit Elementen, an denen sich was geändert hat.

### getListeners

    public EventListener[] getListeners(Class listenerType)

  Gibt ein Array mit allen Listenern des spezifizierten Typs zurück, die sich an diesem Model registriert haben.

  Parameters:
    `listenerType` - Typ des EventListeners.
  Returns:
    Alle registrierten Listener des übergebenen Typs.

### getItemCount

    public int getItemCount()

  Gibt die Anzahl der Items in diesem Model zurück. Hier wird die Anzahl aller Eintraege des Root-Knotens(inklusive) zurueckgegeben. Wenn der Root-Knoten keine Eintraege enthaelt, wird '1' zurueckgegeben, da ja zumindest der Root-Knoten vorhanden ist.

  Overrides:
    `getItemCount` in class `BusinessModel`
  Returns:
    Die Anzahl an Items im Model.

### createNewItem

    public Item createNewItem(String name)
                       throws ItemInstantiateException

  Erzeugt ein neues Item für den Baum. Dieses enthaelt den uebergebenen Namen. Dieser Name erscheint auch in der Baumansicht. Die ID fuer das Item wird automatisch generiert. Der Knoten besitzt kein UserObject und kann Kindknoten enthalten.

  Specified by:
    `createNewItem` in interface `IBusinessModelSave`
  Overrides:
    `createNewItem` in class `BusinessModel`
  Parameters:
    `name` - Der Name für den Knoten.
  Returns:
    Ein neues Item von der Art wie sie in diesem Model verwaltet werden.
  Throws:
    `ItemInstantiateException` - wenn beim erzeugen des Items ein Fehler auftritt.

### createNewItem

    public Item createNewItem(String name,
                              Object userObject)
                       throws ItemInstantiateException

  Erzeugt ein neues Item für den Baum. Dieses enthaelt den uebergebenen Namen. Dieser Name erscheint auch in der Baumansicht. Die ID fuer das Item wird automatisch generiert. Der Knoten besitzt das uebergebene UserObject und kann Kindknoten enthalten.

  Parameters:
    `name` - Der Name für den neuen Knoten.
    `userObject` - Ein vom Knoten verwaltetes Object.
  Returns:
    Ein neues Item von der Art wie sie in diesem Model verwaltet werden.
  Throws:
    `ItemInstantiateException` - wenn beim erzeugen des Items ein Fehler auftritt.

### createNewItem

    public Item createNewItem(String name,
                              boolean askAllowChildren)
                       throws ItemInstantiateException

  Erzeugt ein neues Item für den Baum. Dieses enthaelt den uebergebenen Namen. Dieser Name erscheint auch in der Baumansicht. Die ID fuer das Item wird automatisch generiert. Der Knoten besitzt kein UserObject. Ob er Kindknoten enthalten darf wird durch den Parameter `askAllowChildren` festgelegt.

  Parameters:
    `name` - Der Name für den neuen Knoten.
    `askAllowChildren` - `true`, wenn dieser Knoten Kindknoten enthalten darf.
  Returns:
    Ein neues Item von der Art wie sie in diesem Model verwaltet werden.
  Throws:
    `ItemInstantiateException` - wenn beim erzeugen des Items ein Fehler auftritt.

### createNewItem

    public Item createNewItem(String name,
                              Object userObject,
                              boolean askAllowChildren)
                       throws ItemInstantiateException

  Erzeugt ein neues Item für den Baum. Dieses enthaelt den uebergebenen Namen. Dieser Name erscheint auch in der Baumansicht. Die ID fuer das Item wird automatisch generiert. Der Knoten besitzt das uebergebene UserObject. Ob er Kindknoten enthalten darf wird durch den Parameter `askAllowChildren` festgelegt.

  Parameters:
    `name` - Der Name für den neuen Knoten.
    `userObject` - Ein vom Knoten verwaltetes Object.
    `askAllowChildren` - `true`, wenn dieser Knoten Kindknoten enthalten darf.
  Returns:
    Ein neues Item von der Art wie sie in diesem Model verwaltet werden.
  Throws:
    `ItemInstantiateException` - wenn beim erzeugen des Items ein Fehler auftritt.

### createNewItem

    public Item createNewItem(String name,
                              String itemId)
                       throws ItemInstantiateException

  Erzeugt ein neues Item für den Baum. Dieses enthaelt den uebergebenen Namen. Dieser Name erscheint auch in der Baumansicht. Kindknoten sind uer dieses Item erlaubt. Der Aufrufer muss selbst sicherstellen, das die uebergebene ID eindeutig ist, da es sonst zu Problemen im Model mit der Verwaltung der Items kommen kann.

  Overrides:
    `createNewItem` in class `BusinessModel`
  Parameters:
    `name` - Der Name für den neuen Knoten.
    `itemId` - Eine eindeutige ID fuer dieses Item.
  Returns:
    Ein neues Item von der Art wie sie in diesem Model verwaltet werden.
  Throws:
    `ItemInstantiateException` - wenn beim erzeugen des Items ein Fehler auftritt.

### getSaveItemCount

    public int getSaveItemCount()

  Holt die Anzahl zu speichernder Items aus dem Model. Hier ist das der Root-Knoten, da dieser die komplette Baumstruktur enthält. Das entsprechende Saver-Objekt muss das dann bei Bedarf entsprechend handeln.

  Specified by:
    `getSaveItemCount` in interface `IBusinessModelSave`
  Overrides:
    `getSaveItemCount` in class `BusinessModel`
  Returns:
    Die Anzahl zu speichernder Items im Model. Ist hier immer 1, da nur der Root-Knoten zurueckgegeben wird.
  See Also:
    `Saver`, `BusinessModel.setSaver(Saver)`, `getSaveItem(int)`

### getSaveItem

    public Item getSaveItem(int index)

  Holt das zu speichernde Item aus dem Model. Das ist hier immer der Root-Knoten, da dieser die komplette Baumstruktur enthält. Das entsprechende Saver-Objekt muss das dann bei Bedarf entsprechend handeln.

  Specified by:
    `getSaveItem` in interface `IBusinessModelSave`
  Overrides:
    `getSaveItem` in class `BusinessModel`
  Parameters:
    `index` - Der Index des zu speichernden Items.
  Returns:
    Gibt hier immer den Root-Knoten des Baumes zurueck.
  See Also:
    `Saver`, `BusinessModel.setSaver(Saver)`

### loadItem

    public void loadItem(Item item)

  Das übergebene Item wird im Model wieder gespeichert. Hier muss der Root-Knoten uebergeben werden. Wenn das uebergebene Item nicht vom Typ `TreeItem` ist, wird eine `IllegalArgumentException` ausgeloest.

  Specified by:
    `loadItem` in interface `IBusinessModelSave`
  Overrides:
    `loadItem` in class `BusinessModel`
  Parameters:
    `item` - Ein dem Model hinzuzufügendes Item. Muss hier der Root-Knoten des Baumes sein.

### preLoad

    public void preLoad()

  Aus dem Model werden vor dem neu Laden alle Items gelöscht. Sonst wären alte und neue Items gemischt vorhanden. Für einen Baum ist das nicht nötig, da beim setzen eines neuen Root-Knoten der alte Baum komplett verschwindet.

  Specified by:
    `preLoad` in interface `IBusinessModelSave`
  Overrides:
    `preLoad` in class `BusinessModel`

### getItemComboBox

    public final ComboBoxModel getItemComboBox()

  Aus dem Baummodel kann kein ComboBoxModel erzeugt werden. Deshalb gibt diese Methode immer `NULL` zurueck.

  Overrides:
    `getItemComboBox` in class `BusinessModel`
  Returns:
    Immer NULL.

### getItemListBox

    public final ListModel getItemListBox()

  Aus dem Baummodel kann kein ListModel erzeugt werden. Deshalb gibt diese Methode immer `NULL` zurueck.

  Overrides:
    `getItemListBox` in class `BusinessModel`
  Returns:
    Immer NULL.

### createNewItem

    public Item createNewItem()

  Items fuer einen Baum koennen nur ueber die Methoden
  - `createNewItem(String)`
  - `createNewItem(String, boolean)`
  - `createNewItem(String, Object)`
  - `createNewItem(String, Object, boolean)`
    erzeugt werden. Damit ist dann immer sichergestellt, dass das Item auch einen Namen hat, da dieser fuer die Darstellung im Tree benoetigt wird.

    Bei Aufruf dieser Methode wird eine `UnsupportedOperationException` ausgeloest.

  Overrides:
    `createNewItem` in class `BusinessModel`
  Returns:
    Ein neues Item fuer den Tree.
  Throws:
    `UnsupportedOperationException,` - da ein Aufruf dieser Methode nicht erlaubt ist.

### getItem

    public Item getItem(int index)

  Da die Items in einem Baum keine einfache Listenstruktur darstellen, kann ueber diese Methode kein Item aus dem Model gelesen werden.

  Bei Aufruf dieser Methode wird eine `UnsupportedOperationException` ausgeloest.

  Overrides:
    `getItem` in class `BusinessModel`
  Parameters:
    `index` - Der Index des auszulesenden Items.
  Returns:
    Das Item am uebergebenen Index.
  Throws:
    `UnsupportedOperationException,` - da ein Aufruf dieser Methode nicht erlaubt ist.

### updateItem

    public void updateItem(Item item)

  Items koennen in einem Tree nicht ueber diese Methode geaendert werden. Um mit dem Item zu arbeiten sollte es ueber die Methode

  Overrides:
    `updateItem` in class `BusinessModel`
  Parameters:
    `item` - Das zu aendernde Item.
  Throws:
    `UnsupportedOperationException,` - da ein Aufruf dieser Methode nicht erlaubt ist.
  See Also:
    `Item.getItemID()`

### removeAllItems

    public void removeAllItems()

  Das loeschen aller Items aus einem TreeModel ist nicht moeglich, da immer zumindest der Root-Knoten vorhandensein muss. Wenn denoch ein leerer Baum angezeigt werden soll, so kann ueber die Methode `setRoot(TreeItem)` ein neuer Root-Knoten gesetzt werden, der keine Eintraege enthaelt.

  Bei Aufruf dieser Methode wird eine `UnsupportedOperationException` ausgeloest.

  Overrides:
    `removeAllItems` in class `BusinessModel`
  Throws:
    `UnsupportedOperationException,` - da ein Aufruf dieser Methode nicht erlaubt ist.

### removeItem

    public void removeItem(Item item)

  Items koennen nicht direkt aus dem Model geloescht werden. Hier ist es erst erforderlich, den Parent-Knoten des zu loeschenden Items zu bestimmen. Dann kann aus diesem Item das zu loeschende Item entfernt werden. Damit verschwindet es dann auch aus der Baumansicht.

  Bei Aufruf dieser Methode wird eine `UnsupportedOperationException` ausgeloest.

  Overrides:
    `removeItem` in class `BusinessModel`
  Parameters:
    `item` - Das zu loeschende Item.
  Throws:
    `UnsupportedOperationException,` - da ein Aufruf dieser Methode nicht erlaubt ist.
  See Also:
    `TreeItem.remove(int)`, `TreeItem.remove(MutableTreeNode)`, `TreeItem.removeFromParent()`

### addItem

    public void addItem(Item item)

  Ueber diese Methode kann dem Model(bzw. dem Baum) kein neuer Eintrag hinzugefuegt werden. Das muss ueber die Methoden
  `insertNodeInto(MutableTreeNode, MutableTreeNode)` oder
  `insertNodeInto(MutableTreeNode, MutableTreeNode, int)`
  geschehen.

  Bei Aufruf dieser Methode wird eine `UnsupportedOperationException` ausgeloest.

  Overrides:
    `addItem` in class `BusinessModel`
  Parameters:
    `item` - Das dem Model hinzuzufuegende Item.
  Throws:
    `UnsupportedOperationException,` - da ein Aufruf dieser Methode nicht erlaubt ist.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD