"

 COPYRIGHT (c) 1999 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Object subclass:#HierarchicalItem

	instanceVariableNames:'parent children isExpanded'

	classVariableNames:''

	poolDictionaries:''

	category:'Views-Support'

!

HierarchicalItem subclass:#Example

	instanceVariableNames:'label icon'

	classVariableNames:'PenguinIcon'

	poolDictionaries:''

	privateIn:HierarchicalItem

!

!HierarchicalItem class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1999 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Hierarchical Items are mostly like Models, but the list of

    dependencies are kept by its HierarchicalList.

    The class is used to build up hierarchical trees.

    [Instance variables:]

        parent      <Item, List or nil>         parent or my HierarchicalList.

        children    <Collection or nil>         list of children

        isExpanded  <Boolean>                   indicates whether the item is

                                                expanded or collapsed

    [author:]

        Claus Atzkern

    [see also:]

        HierarchicalList

        HierarchicalListView

"

! !

!HierarchicalItem class methodsFor:'instance creation'!

new

    ^ (self basicNew) initialize

! !

!HierarchicalItem methodsFor:'accessing'!

level

    "returns the level starting with 1

    "

    |parent

     level "{ Class:SmallInteger }"

    |

    level  := 0.

    parent := self.

    [(parent := parent parentOrModel) notNil] whileTrue:[

        level := level + 1

    ].

    ^ level

!

parent

    "returns the parent or nil

    "

    ^ (parent notNil and:[parent isHierarchicalItem]) ifTrue:[parent]

                                                     ifFalse:[nil]

!

parent:aParent

    "set the parent (or the model if the item is the root item)

    "

    parent := aParent

! !

!HierarchicalItem methodsFor:'accessing children'!

at:anIndex

    "returns the child under an index or nil

    "

  ^ self children notNil ifTrue:[children at:anIndex ifAbsent:nil]

                        ifFalse:[nil]

!

at:anIndex put:anItem

    "replace a child by a new item

    "

    |oldItem itemExpanded size|

    size := self children size.

    (anIndex between:1 and:size) ifFalse:[

        ^ self subscriptBoundsError

    ].

    anItem isNil ifTrue:[

        ^ self removeFromIndex:anIndex toIndex:anIndex.

    ].

    oldItem := children at:anIndex.

    oldItem collapse.

    itemExpanded := anItem isExpanded.

    anItem setExpanded:false.

    children at:anIndex put:anItem.

    self changed.

    itemExpanded ifTrue:[

        anItem expand

    ].

!

children:aListOfChildren

    "set a new list of children

    "

    self removeAll.

  ^ self addAll:aListOfChildren beforeIndex:1

!

first

    "returns the first child

    "

    ^ self at:1

!

last

    "returns the last child

    "

    ^ self at:(self children size)

! !

!HierarchicalItem methodsFor:'accessing hierarchy'!

collapse

    "hide children

    "

    |visChd model index|

    self canCollapse ifTrue:[

        isExpanded := false.

        (index := self listIndex) notNil ifTrue:[

            (visChd := children size) ~~ 0 ifTrue:[

                children do:[:aChild|

                    visChd := visChd + aChild numberOfVisibleChildren

                ].

                self model itemRemoveFromIndex:(index + 1)

                                       toIndex:(index + visChd).

                index ~~ 0 ifTrue:[

                    self hierarchyChanged

                ]

            ]

        ]

    ]

!

expand

    "expand children

    "

    |index list|

    self canExpand ifTrue:[

        isExpanded := true.

        (index := self listIndex) notNil ifTrue:[

            (children notNil or:[self children notNil]) ifTrue:[

                children notEmpty ifTrue:[

                    list := OrderedCollection new:64.

                    self addVisibleChildrenTo:list.

                    self model itemAddAll:list beforeIndex:(index + 1).

                ].

                index ~~ 0 ifTrue:[

                    self hierarchyChanged

                ]

            ]

        ]

    ]

!

makeVisible

    "expand all my parents

    "

    (parent notNil and:[parent isHierarchicalItem]) ifTrue:[

        parent expand.

        parent makeVisible

    ].

!

recursiveCollapse

    "collapse children and sub-children

     **** must be expanded

    "

    |visChd index|

    self canCollapse ifTrue:[

        (index := self listIndex) notNil ifTrue:[

            (visChd := children size) ~~ 0 ifTrue:[

                children do:[:aChild|

                    visChd := visChd + aChild numberOfVisibleChildren

                ]

            ].

            self recursiveSetCollapsed.

            visChd ~~ 0 ifTrue:[

                self model itemRemoveFromIndex:(index + 1)

                                       toIndex:(index + visChd)

            ].

            index ~~ 0 ifTrue:[

                self hierarchyChanged

            ]

        ] ifFalse:[

            self recursiveSetCollapsed

        ]

    ]

!

recursiveExpand

    "expand children and sub-children

     **** must be collapsed

    "

    |model index list|

    self canExpand ifTrue:[

        isExpanded := true.

        self children size ~~ 0 ifTrue:[

            (index := self listIndex) isNil ifTrue:[

                children do:[:aChild| aChild setExpanded:true ]

            ] ifFalse:[

                list := OrderedCollection new:512.

                self recursiveSetExpandedAndAddToList:list.

                self model itemAddAll:list beforeIndex:(index + 1).

                index ~~ 0 ifTrue:[

                    self hierarchyChanged

                ]

            ]

        ]

    ]

!

recursiveToggleExpand

    "if the item is collapsed, the children and all sub-children

     are expanded otherwise collapsed

    "

    isExpanded ifTrue:[self recursiveCollapse] ifFalse:[self recursiveExpand]

!

toggleExpand

    "if the item is collapsed, the children are expanded

     otherwise collapsed

    "

    isExpanded ifTrue:[self collapse] ifFalse:[self expand]

! !

!HierarchicalItem methodsFor:'accessing mvc'!

application

    "returns the responsible application or nil

    "

    |model|

    (model := self model) notNil ifTrue:[

        ^ model application

    ].

    ^ nil

!

applicationsDo:aOneArgBlock

    "evaluate the block on each dependent application

    "

    |model|

    (model := self model) notNil ifTrue:[

        model applicationsDo:aOneArgBlock

    ]

!

model

    "returns the hierachicalList model or nil

    "

    |p model|

    model := self.

    [(p := model parentOrModel) notNil] whileTrue:[model := p].

  ^ model isHierarchicalItem ifFalse:[model] ifTrue:[nil]

! !

!HierarchicalItem methodsFor:'adding & removing'!

add:aChildItem

    "add a child at end

    "

    ^ self add:aChildItem beforeIndex:(self children size + 1).

!

add:aChildItem after:aChild

    "add an item after an existing item

    "

    |index|

    (index := self listIndex) isNil ifTrue:[

        self subscriptBoundsError

    ] ifFalse:[

        self add:aChildItem beforeIndex:(index + 1)

    ].

    ^ aChildItem

!

add:aChildItem afterIndex:anIndex

    "add an item after an index

    "

    ^ self add:aChildItem beforeIndex:(anIndex + 1).

!

add:aChildItem before:aChild

    "add an item before an existing item

    "

    |index|

    (index := self identityIndexOf:aChild) ~~ 0 ifTrue:[

        ^ self add:aChildItem beforeIndex:index

    ].

    self subscriptBoundsError

!

add:aChildItem beforeIndex:anIndex

    "add an item before an index

    "

    aChildItem notNil ifTrue:[

        self addAll:(Array with:aChildItem) beforeIndex:anIndex

    ].

    ^ aChildItem

!

add:aChild sortBlock:aBlock

    "add a child sorted

    "

    (aBlock notNil and:[children size ~~ 0]) ifTrue:[

        children keysAndValuesDo:[:index :child|

            (aBlock value:aChild value:child) ifTrue:[

                ^ self add:aChild beforeIndex:index

            ]

        ]

    ].

    ^ self add:aChild

!

addAll:aList

    "add children at the end

    "

    ^ self addAll:aList beforeIndex:(self children size + 1)

!

addAll:aList beforeIndex:anIndex

    "add children before an index

    "

    |coll model notify

     index "{ Class:SmallInteger }"

     size  "{ Class:SmallInteger }"

    |

    (aList isNil or:[aList isEmpty]) ifTrue:[

        ^ aList

    ].

    size := self children size.

    anIndex == 1 ifTrue:[

        notify := self

    ] ifFalse:[

        anIndex > size ifTrue:[

            anIndex > (1 + size) ifTrue:[

                ^ self subscriptBoundsError

            ].

            notify := self at:size

        ] ifFalse:[

            notify := nil

        ]

    ].

    size == 0 ifTrue:[

        children := OrderedCollection new

    ].

    aList do:[:anItem| anItem parent:self ].

    children addAll:aList beforeIndex:anIndex.

    (model := self model) isNil ifTrue:[

        ^ aList

    ].

    isExpanded ifFalse:[

        notify notNil ifTrue:[

            notify changed

        ].

      ^ aList

    ].

    (index := self listIndex) isNil ifTrue:[

        ^ aList

    ].

    children from:1 to:(anIndex - 1) do:[:anItem|

        index := 1 + index + anItem numberOfVisibleChildren

    ].

    coll := OrderedCollection new.

    aList do:[:anItem|

        coll add:anItem.

        anItem addVisibleChildrenTo:coll.

    ].

    model itemAddAll:coll beforeIndex:(index + 1).

    notify notNil ifTrue:[

        notify changed

    ].

  ^ aList

!

addAllFirst:aCollectionOfItems

    "add children at the beginning

    "

    ^ self addAll:aCollectionOfItems beforeIndex:1

!

addAllLast:aCollectionOfItems

    "add children at the end

    "

    ^ self addAll:aCollectionOfItems

!

addFirst:aChildItem

    "add a child at begin

    "

    ^ self add:aChildItem beforeIndex:1.

!

addLast:anItem

    "add a child at end

    "

    ^ self add:anItem

!

remove:aChild

    "remove a child

    "

    self removeIndex:(self identityIndexOf:aChild)

!

removeAll

    "remove all children

    "

    |size|

    (size := self children size) ~~ 0 ifTrue:[

        self removeFromIndex:1 toIndex:size

    ]

!