Procedure TreeLL(modus.l, *TreeLL_In)
  Enumeration 1
    #TLL_NewTreeLL    ;Erstellt eine neue TreeLinkedList mit der Structuregröße *TreeLL_in und gibt ihr Handle zurück
    #TLL_NewChild     ;Erstellt unter dem aktuellen Element eine neue Childliste oder springt zum aktuellen Child des aktuellen Elementes
    
    #TLL_Add          ;Erstellt ein neues Element nach dem aktuellen oder in der neuen Childliste
    #TLL_Insert       ;Erstellt ein neues Element vor dem aktuellen
    #TLL_Delete       ;Löscht das aktuelle Element und seine Childs, falls vorhanden
    #TLL_AllDelete    ;Löscht alle Elemente
    
    #TLL_FreeTreeLL   ;Löscht die TreeLL und gibt den Speicher wieder frei
    
    #TLL_Reset        ;Resetet die aktuelle Liste, nicht die ganze
    #TLL_ResetAll     ;Resetet jede einzelne Liste
    #TLL_First        ;Springt zum ersten Element in der aktuellen Liste
    #TLL_Last         ;Springt zum letzten Element in der aktuellen Liste
    #TLL_LastMain     ;Springt zum letzten Element in der gesamten Liste
    #TLL_FirstMain    ;Springt zum ersten Element in der ersten Ebene
    
    #TLL_Prev         ;Springt zu dem Element vor dem aktuellen
    #TLL_Next         ;Springt zu dem Element nach dem aktuellen oder zum ersten, wenn die Liste resetet wurde
    #TLL_NextEx       ;Springt zum nächsten Element oder
    #TLL_Child        ;Springt zum aktuellen Child des aktuellen Elementes oder vor die Childliste
    #TLL_Parent       ;Springt zum Parent des aktuellen Elementes
    
    #TLL_GetPointer   ;Gibt den Pointer zum aktuellen Element zurück
    
    #TLL_IsPrev       ;Gibt 0 zurück, wenn kein Element vor dem aktuellen existiert, sonst Pointer zum vorherigen Element
    #TLL_IsNext       ;Gibt 0 zurück, wenn kein Element nach dem aktuellen existiert, sonst Pointer zum folgenden Element
    #TLL_IsChild      ;Gibt 0 zurück, wenn das aktuelle Element kein Child hat, sonst Pointer zum Child
    #TLL_IsParent     ;Gibt 0 zurück, wenn das aktuelle Element kein Parent hat, sonst Pointer zum Parent
    
    #TLL_CountChilds  ;Zählt die Childs des aktuellen Elements
    #TLL_CountList    ;Zählt die Elemente der aktuellen Ebene
    #TLL_CountElements;Zählt die Elemente der gesamten Liste
    #TLL_CountColumn  ;Zählt die Rekursion eines Childs
    
    #TLL_SaveTreeLL
    #TLL_LoadTreeLL
    
    #TLL_ChangeElement
  EndEnumeration
  Structure TreeLinkedListElement
    *pNext.TreeLinkedListElement
    *pPrev.TreeLinkedListElement
    *pParent.TreeLinkedListElement
    *pChild.TreeLinkedListElement
    *pChildLast.TreeLinkedListElement
    *pAktChild.TreeLinkedListElement
  EndStructure
  Structure TreeLinkedList
    *pAktElement.TreeLinkedListElement
    *pFirstElement.TreeLinkedListElement
    *pLastElement.TreeLinkedListElement
    ElementSize.l
    Status.l
  EndStructure
  Structure TreeLinkedListAllTypes
    StructureUnion
      b.b
      w.w
      l.l
      f.f
      s.s
    EndStructureUnion
  EndStructure

  ;{ Init
  Protected *New.TreeLinkedListElement, *TreeLL.TreeLinkedList
  Protected TreeLLSize.l, Count.l, OK.l, AktElementSize.l, *z.BYTE, *AllTypes.TreeLinkedListAllTypes, Struc.s, TmpS.s
  ;}
  
  If modus = #TLL_NewTreeLL       ;{ Reserviert Speicher für eine neue TreeLL und gibt das Handle zurück
    If *TreeLL_In
      *TreeLL = AllocateMemory(SizeOf(TreeLinkedList))
      *TreeLL\ElementSize = *TreeLL_In
      *TreeLL\Status = 0
      ProcedureReturn *TreeLL
    EndIf
    ProcedureReturn 0
  EndIf;}
  
  If modus = #TLL_LoadTreeLL      ;{ Läd eine TreeLL und gibt das Handle zurück
    *TreeLL = TreeLL(#TLL_NewTreeLL, ReadLong())
    Struc = ""
    Count = 0
    Repeat
      OK = ReadByte() & $FF
      If OK : Struc = Struc + Chr(OK) : EndIf
    Until OK = 0
    Repeat
      OK = ReadByte()
      Select OK
        Case 0
          *AllTypes = TreeLL(#TLL_Add, *TreeLL)
        Case 1
          TreeLL(#TLL_NewChild, *TreeLL)
        Case 2
          TreeLL(#TLL_Parent, *TreeLL)
      EndSelect
      
      If OK = 0
        *z = @Struc
        While *z\b
          Select *z\b
            Case 'b'
              *AllTypes\b = ReadByte()
              *AllTypes + 1
            Case 'w'
              *AllTypes\w = ReadWord()
              *AllTypes + 2
            Case 'l'
              *AllTypes\l = ReadLong()
              *AllTypes + 4
            Case 'f'
              *AllTypes\f = ReadFloat()
              *AllTypes + 4
            Case 's'
              Count = ReadLong()
              *AllTypes\s = Space(Count)
              ReadData(*AllTypes\l, Count)
              *AllTypes + 4
          EndSelect
          *z + 1
        Wend
      EndIf
    Until OK >= 3
    *AllTypes = 0
    If OK > 3 : ProcedureReturn 0 : EndIf
    ProcedureReturn *TreeLL
  EndIf;}
  
  ;{ PastInit
  *TreeLL = *TreeLL_In
  If *TreeLL                  ;Überprüft das Handle auf Gültigkeit
    If *TreeLL\ElementSize = 0
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  TreeLLSize = SizeOf(TreeLinkedListElement)
  AktElementSize = TreeLLSize + *TreeLL\ElementSize;}
  
  If *TreeLL\Status = #TLL_SaveTreeLL   ;{ Speichert die gesamte TreeLL in eine geöffnete Datei
    WriteLong(*TreeLL\ElementSize)
    WriteString(PeekS(Modus))
    WriteByte(0)
    
    If *TreeLL\pFirstElement
      *New = *TreeLL\pFirstElement
      Repeat
        WriteByte(0)
        *z = Modus
        *AllTypes = *New + TreeLLSize
        While *z\b
          Select *z\b
            Case 'b'
              WriteByte(*AllTypes\b)
              *AllTypes + 1
            Case 'w'
              WriteWord(*AllTypes\w)
              *AllTypes + 2
            Case 'l'
              WriteLong(*AllTypes\l)
              *AllTypes + 4
            Case 'f'
              WriteFloat(*AllTypes\f)
              *AllTypes + 4
            Case 's'
              WriteLong(Len(*AllTypes\s))
              WriteString(*AllTypes\s)
              *AllTypes + 4
          EndSelect
          *z + 1
        Wend
        
        If *New\pChild
          *New = *New\pChild
          WriteByte(1)
        Else
          While *New\pNext = 0 And *New\pParent
            *New = *New\pParent
            WriteByte(2)
          Wend
          *New = *New\pNext
        EndIf
      Until *New = 0
      WriteByte(3)
      *TreeLL\Status = 0
      ProcedureReturn 1
    EndIf
    *TreeLL\Status = 0
    ProcedureReturn 0
  EndIf;}
  
  If *TreeLL\Status = #TLL_ChangeElement ;{ Springt zum Element an einer bestimmten Adresse
    If Modus
      *TreeLL\pAktElement = Modus - TreeLLSize
    EndIf
    *TreeLL\Status = 0
    ProcedureReturn 1
  EndIf ;}
  
  ;{ Select
  Select modus
    Case #TLL_GetPointer    ;{ Gibt den Pointer zum aktuellen Element zurück
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          ProcedureReturn -1
        Else
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      ElseIf *TreeLL\pFirstElement
        ProcedureReturn -1
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_Add           ;{ Füge ein neues Element hinter dem Aktuellen ein
      *New = AllocateMemory(AktElementSize)
      
      If *TreeLL\pAktElement And *TreeLL\pAktElement\pAktChild <> -1    ;Wenn Element aktiv ist
        If *TreeLL\pAktElement\pChild = -1        ;Wenn ein Child erstellt werden soll
          *TreeLL\pAktElement\pChild = *New
          *TreeLL\pAktElement\pChildLast
          *New\pParent = *TreeLL\pAktElement
        Else
          *New\pNext = *TreeLL\pAktElement\pNext
          *New\pPrev = *TreeLL\pAktElement
          *TreeLL\pAktElement\pNext = *New
          If *New\pNext
            *New\pNext\pPrev = *New
          EndIf
          *New\pParent = *TreeLL\pAktElement\pParent
          If *New\pPrev = 0           ;Wenn 1. Pos hat
            If *New\pParent
              *New\pParent\pChild = *New
            Else
              *TreeLL\pFirstElement = *New
            EndIf
          EndIf
          If *New\pNext = 0           ;Wenn letzte Pos hat
            If *New\pParent
              *New\pParent\pChildLast = *New
            Else
              *TreeLL\pLastElement = *New
            EndIf
          EndIf
        EndIf
      ElseIf *TreeLL\pFirstElement       ;Wenn resettet wurde
        *New\pNext = *TreeLL\pFirstElement
        *TreeLL\pFirstElement\pPrev = *New
        *TreeLL\pFirstElement = *New
      Else                      ;Wenn noch kein Element vorhanden war
        *TreeLL\pFirstElement = *New
        *TreeLL\pLastElement = *New
      EndIf
      *TreeLL\pAktElement = *New
      ProcedureReturn *New + TreeLLSize;}
    
    Case #TLL_Insert        ;{ Füge ein neues Element ein
      *New = AllocateMemory(AktElementSize)
      If *TreeLL\pAktElement And *TreeLL\pAktElement\pAktChild <> -1    ;Wenn Element aktiv ist
        If *TreeLL\pAktElement\pChild = -1        ;Wenn ein Child erstellt werden soll
          *TreeLL\pAktElement\pChild = *New
          *TreeLL\pAktElement\pChildLast
          *New\pParent = *TreeLL\pAktElement
        Else
          *New\pNext = *TreeLL\pAktElement
          *New\pPrev = *TreeLL\pAktElement\pPrev
          *TreeLL\pAktElement\pPrev = *New
          If *New\pPrev
            *New\pPrev\pNext = *New
          EndIf
          *New\pParent = *TreeLL\pAktElement\pParent
          If *New\pPrev = 0           ;Wenn 1. Pos hat
            If *New\pParent
              *New\pParent\pChild = *New
            Else
              *TreeLL\pFirstElement = *New
            EndIf
          EndIf
          If *New\pNext = 0           ;Wenn letzte Pos hat
            If *New\pParent
              *New\pParent\pChildLast = *New
            Else
              *TreeLL\pLastElement = *New
            EndIf
          EndIf
        EndIf
      ElseIf *TreeLL\pFirstElement   ;Wenn resettet wurde
        *New\pNext = *TreeLL\pFirstElement
        *TreeLL\pFirstElement\pPrev = *New
        *TreeLL\pFirstElement = *New
      Else                      ;Wenn noch kein Element vorhanden war
        *TreeLL\pFirstElement = *New
        *TreeLL\pLastElement = *New
      EndIf
      *TreeLL\pAktElement = *New
      ProcedureReturn *New + TreeLLSize;}
    
    Case #TLL_Next          ;{ Springe zum nächsten Element
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
          *TreeLL\pAktElement = *TreeLL\pAktElement\pChild
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pNext
          *TreeLL\pAktElement = *TreeLL\pAktElement\pNext
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      ElseIf *TreeLL\pFirstElement
        *TreeLL\pAktElement = *TreeLL\pFirstElement
        ProcedureReturn *TreeLL\pAktElement + TreeLLSize
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_Reset         ;{ Resete die aktuelle Rekursion
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pParent
          *TreeLL\pAktElement\pParent\pAktChild = -1
          *TreeLL\pAktElement = *TreeLL\pAktElement\pParent
          ProcedureReturn 1
        Else
          *TreeLL\pAktElement = 0
          ProcedureReturn 1
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_ResetAll      ;{ Resetet jede Liste
      If *TreeLL\pFirstElement
        *New = *TreeLL\pFirstElement
        c = 0
        Repeat
          If *New\pChild
            *New\pAktChild = 0
            *New = *New\pChild
          Else
            While *New\pNext = 0 And *New\pParent
              *New = *New\pParent
            Wend
            *New = *New\pNext
          EndIf
          c + 1
        Until *New = 0
        *TreeLL\pAktElement = 0
        ProcedureReturn 1
      EndIf
      ProcedureReturn 0
      ;}
    
    Case #TLL_Delete        ;{ Löscht das aktuelle Element samt seinen Childs
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pChild
          *New = *TreeLL\pAktElement\pChild
          Repeat
            If *New\pChild
              *New = *New\pChild
            Else
              While *New\pNext = 0 And *New\pParent <> *TreeLL\pAktElement
                *New\pParent\pChild = *New
                *New = *New\pParent
                FreeMemory(*New\pChild)
              Wend
              If *New\pNext
                *New = *New\pNext
                FreeMemory(*New\pPrev)
              Else
                FreeMemory(*New)
                *New = 0
              EndIf
            EndIf
          Until *New = 0
        EndIf
        ;{ Hier gehts weiter
        *New = *TreeLL\pAktElement
        If *TreeLL\pAktElement\pPrev
          *TreeLL\pAktElement\pPrev\pNext = *TreeLL\pAktElement\pNext
        Else
          If *TreeLL\pAktElement\pParent
            *TreeLL\pAktElement\pParent\pChild = *TreeLL\pAktElement\pNext
          Else
            *TreeLL\pFirstElement = *TreeLL\pAktElement\pNext
          EndIf
        EndIf
        If *TreeLL\pAktElement\pNext
          *TreeLL\pAktElement\pNext\pPrev = *TreeLL\pAktElement\pPrev
        Else
          If *TreeLL\pAktElement\pParent
            *TreeLL\pAktElement\pParent\pChildLast = *TreeLL\pAktElement\pPrev
          Else
            *TreeLL\pLastElement = *TreeLL\pAktElement\pPrev
          EndIf
        EndIf
        If *TreeLL\pAktElement\pParent
          If *TreeLL\pAktElement\pParent\pAktChild = *TreeLL\pAktElement
            *TreeLL\pAktElement\pParent\pAktChild = 0
          EndIf
        EndIf
        
        If *TreeLL\pAktElement\pPrev = 0
          If *TreeLL\pAktElement\pParent
            *TreeLL\pAktElement = *TreeLL\pAktElement\pParent
            *TreeLL\pAktElement\pAktChild = -1
          Else
            *TreeLL\pAktElement = 0
          EndIf
        Else
          *TreeLL\pAktElement = *TreeLL\pAktElement\pPrev
        EndIf
        FreeMemory(*New)
        ProcedureReturn 1
      EndIf;}
      ProcedureReturn 0;}
    
    Case #TLL_AllDelete     ;{ Löscht alle Elemente
      If *TreeLL\pFirstElement
        *New = *TreeLL\pFirstElement
        Repeat
          If *New\pChild
            *New = *New\pChild
          Else
            While *New\pNext = 0 And *New\pParent
              *New\pParent\pChild = *New
              *New = *New\pParent
              FreeMemory(*New\pChild)
            Wend
            If *New\pNext
              *New = *New\pNext
              FreeMemory(*New\pPrev)
            Else
              FreeMemory(*New)
              *New = 0
            EndIf
          EndIf
        Until *New = 0
        *TreeLL\pAktElement = 0
        *TreeLL\pFirstElement = 0
        *TreeLL\pLastElement = 0
        ProcedureReturn 1
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_NewChild      ;{ Erstelle das Grundgerüst für ein neues Child oder springe zum Child
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pChild = 0
          *TreeLL\pAktElement\pChild = -1
          ProcedureReturn -1
        ElseIf *TreeLL\pAktElement\pChild <> -1
          If *TreeLL\pAktElement\pAktChild = 0 Or *TreeLL\pAktElement\pAktChild = -1
            *TreeLL\pAktElement\pAktChild = -1
            ProcedureReturn -1
          Else
            *TreeLL\pAktElement = *TreeLL\pAktElement\pAktChild
          EndIf
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_Child         ;{ Springe zum aktuellen Child
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pChild And *TreeLL\pAktElement\pChild <> -1
          If *TreeLL\pAktElement\pAktChild = 0 Or *TreeLL\pAktElement\pAktChild = -1
            *TreeLL\pAktElement\pAktChild = -1
            ProcedureReturn -1
          Else
            *TreeLL\pAktElement = *TreeLL\pAktElement\pAktChild
            ProcedureReturn *TreeLL\pAktElement + TreeLLSize
          EndIf
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_Parent        ;{ Springe zum Parent
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pChild = -1
          *TreeLL\pAktElement\pChild = 0
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pParent
          *TreeLL\pAktElement\pParent\pAktChild = *TreeLL\pAktElement
          *TreeLL\pAktElement = *TreeLL\pAktElement\pParent
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_IsParent      ;{ Hat dieses Element ein Parent?
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pParent And *TreeLL\pAktElement\pAktChild <> -1
          ProcedureReturn *TreeLL\pAktElement\pParent + TreeLLSize
        Else
          ProcedureReturn 0
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_Last          ;{ Springe zum letzten Element
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
          *TreeLL\pAktElement = *TreeLL\pAktElement\pChild
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pParent
          *TreeLL\pAktElement = *TreeLL\pAktElement\pParent\pChildLast
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        Else
          *TreeLL\pAktElement = *TreeLL\pLastElement
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_LastMain      ;{ Springe zum letzten Element in der gesamten Liste
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
        EndIf
        *New = *TreeLL\pLastElement
        While *New\pChildLast
          *New = *New\pChildLast
        Wend
        *TreeLL\pAktElement = *New
        ProcedureReturn *TreeLL\pAktElement + TreeLLSize
      EndIf;}
    
    Case #TLL_First         ;{ Springe zum ersten Element
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
          *TreeLL\pAktElement = *TreeLL\pAktElement\pChild
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pParent
          *TreeLL\pAktElement = *TreeLL\pAktElement\pParent\pChild
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        Else
          *TreeLL\pAktElement = *TreeLL\pFirstElement
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_FirstMain     ;{ Springe zum ersten Element der ersten Ebene
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
          *TreeLL\pAktElement = *TreeLL\pFirstElement
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        Else
          *TreeLL\pAktElement = *TreeLL\pFirstElement
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_IsNext        ;{ Folgt diesem Element noch eins?
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          ProcedureReturn *TreeLL\pAktElement\pChild + TreeLLSize
        ElseIf *TreeLL\pAktElement\pNext
          ProcedureReturn *TreeLL\pAktElement\pNext + TreeLLSize
        Else
          ProcedureReturn 0
        EndIf
      ElseIf *TreeLL\pFirstElement
        ProcedureReturn *TreeLL\pFirstElement + TreeLLSize
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_NextEx        ;{ Springe zum nächsten Element oder zum Parent und zu dessen Nachfolger
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pAktChild = -1
          *TreeLL\pAktElement\pAktChild = 0
          *TreeLL\pAktElement = *TreeLL\pAktElement\pChild
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pChild
          *TreeLL\pAktElement = *TreeLL\pAktElement\pChild
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        ElseIf *TreeLL\pAktElement\pNext
          *TreeLL\pAktElement = *TreeLL\pAktElement\pNext
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        Else
          While *TreeLL\pAktElement\pParent And *TreeLL\pAktElement\pNext = 0
            *TreeLL\pAktElement = *TreeLL\pAktElement\pParent
          Wend
          If *TreeLL\pAktElement\pNext
            *TreeLL\pAktElement = *TreeLL\pAktElement\pNext
            ProcedureReturn *TreeLL\pAktElement + TreeLLSize
          Else
            ProcedureReturn 0
          EndIf
        EndIf
      ElseIf *TreeLL\pFirstElement
        *TreeLL\pAktElement = *TreeLL\pFirstElement
        ProcedureReturn *TreeLL\pAktElement + TreeLLSize
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_IsChild       ;{ Hat dieses Element ein Child?
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pChild And *TreeLL\pAktElement\pAktChild <> -1
          ProcedureReturn *TreeLL\pAktElement\pChild + TreeLLSize
        Else
          ProcedureReturn 0
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_Prev          ;{ Springe zum vorherigen Element
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pPrev And *TreeLL\pAktElement\pAktChild <> -1
          *TreeLL\pAktElement = *TreeLL\pAktElement\pPrev
          ProcedureReturn *TreeLL\pAktElement + TreeLLSize
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_IsPrev        ;{ Geht diesem Element eins voraus?
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pPrev And *TreeLL\pAktElement\pAktChild <> -1
          ProcedureReturn *TreeLL\pAktElement\pPrev + TreeLLSize
        Else
          ProcedureReturn 0
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_CountChilds   ;{ Gibt die Anzahl der Childs zurück
      If *TreeLL\pAktElement
        If *TreeLL\pAktElement\pChild
          *New = *TreeLL\pAktElement\pChild
          Count = 1
          While *New\pNext
            *New = *New\pNext
            Count + 1
          Wend
          ProcedureReturn Count
        Else
          ProcedureReturn 0
        EndIf
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_CountList     ;{ Gibt die Anzahl der Elemente in dieser Rekursion zurück
      If *TreeLL\pFirstElement
        *New = *TreeLL\pFirstElement
      Else
        ProcedureReturn 0
      EndIf
      
      Count = 1
      While *New\pNext
        *New = *New\pNext
        Count + 1
      Wend
      ProcedureReturn Count;}
    
    Case #TLL_CountElements ;{ Gibt die Anzahl aller Elemente zurück
      If *TreeLL\pFirstElement
        *New = *TreeLL\pFirstElement
        Count = 0
        Repeat
          If *New\pChild
            *New = *New\pChild
            Count + 1
          Else
            While *New\pNext = 0 And *New\pParent
              *New = *New\pParent
            Wend
            *New = *New\pNext
            Count + 1
          EndIf
        Until *New = 0
        ProcedureReturn Count
      EndIf
      ProcedureReturn 0;}
    
    Case #TLL_CountColumn   ;{ Gibt die Anzahl der Rekursion des Elements zurück
      If *TreeLL\pAktElement
        Count = 0
        If *TreeLL\pAktElement\pAktChild = -1
          *New = *TreeLL\pAktElement\pAktChild
        Else
          *New = *TreeLL\pAktElement
        EndIf
        While *New\pParent
          Count + 1
          *New = *New\pParent
        Wend
        ProcedureReturn Count
      EndIf
      ProcedureReturn 0;}

    Case #TLL_SaveTreeLL    ;{ Speichert die gesamte TreeLL in eine geöffnete Datei (s.o.)
      *TreeLL\Status = #TLL_SaveTreeLL
      ProcedureReturn 1;}
    
    Case #TLL_ChangeElement ;{ Springt zum Element an einer bestimmten Adresse
      *TreeLL\Status = #TLL_ChangeElement
      ProcedureReturn 1;}
    
    Case #TLL_FreeTreeLL    ;{ Löscht die TreeLL und gibt den Speicher wieder frei
      If TreeLL(#TLL_AllDelete, *TreeLL)
        If FreeMemory(*TreeLL)
          ProcedureReturn 1
        EndIf
      EndIf
      ProcedureReturn 0
    
    Default
      ProcedureReturn 0;}
  EndSelect;}
EndProcedure
; jaPBe Version=2.5.4.22
; FoldLines=00010029002A003100320038003900410043004600480050005200820084008F
; FoldLines=009100C300C500CB00CF00D900DB01030105012C012E013C013E0149014B015F
; FoldLines=0161019F0178000001A101BB01BD01CC01CE01DA01DC01EA01EC01F401F60204
; FoldLines=02060211021302210223022E0230023C023E0259025B02630265026C026E0276
; FoldLines=0278028602880294029602A802AA02B802BA02BC02BE02C002C202CB
; Build=2
; Language=0x0000 Language Neutral
; FirstLine=15
; CursorPosition=353
; EnableAsm
; ExecutableFormat=Windows
; Executable=C:\Programme\PureBasic\Programme\Projekte\TreeLinkedList\test.exe
; DontSaveDeclare
; EOF