"

 COPYRIGHT (c) 1997 by eXept Software AG / Claus Gittinger

              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.

"

"{ Package: 'stx:libwidg2' }"

Model subclass:#SelectionInTree

	instanceVariableNames:'root list selection showRoot contentsAction labelAction

		childrenAction iconAction indicatorList indicatorTask accessLock'

	classVariableNames:''

	poolDictionaries:''

	category:'Interface-Support-Models'

!

!SelectionInTree class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1997 by eXept Software AG / Claus Gittinger

              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

"

    list and selection holder for hierarchical list structures. Used

    to buildup file-trees, class trees etc.

    Especially suited for use with SelectionInTreeView.

    Notice: this class replaces SelectionInHierarchy, which provides

            similar (but less sphisticated) functionality.

    [See also:]

        TreeItem

        SelectionInTreeView

    [Author:]

        W. Olberding

        Claus Atzkern

"

! !

!SelectionInTree class methodsFor:'instance creation'!

new

    ^ self basicNew initialize

! !

!SelectionInTree class methodsFor:'defaults'!

defaultItemClass

    "returns the default item class or nil (the default)

    "

    ^ nil

! !

!SelectionInTree methodsFor:'accessing'!

list

    "get the list of currently shown objects

    "

    ^ list

!

root

    "get the root node

    "

    ^ root

!

root:aRoot

    "set a new root

    "

    |tree|

    root notNil ifTrue: [

        tree := root tree.

        root tree:nil.

    ] ifFalse:[

        tree := self

    ].

    self stopRunningTasks.

    (root := aRoot) notNil ifTrue:[

        root tree:tree.

        root parent:nil.

    ].

    self recomputeList

!

value

    ^ list

! !

!SelectionInTree methodsFor:'accessing hierarchy new'!

doMakeVisible:something

    "make an item or list of items to become visible

    "

    |anchor parent|

    self each:something do:[:anItem|

        parent := anItem.

        anchor := nil.

        parent notNil ifTrue:[

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

                parent hidden ifTrue:[

                    anchor notNil ifTrue:[ anchor expand ].

                    anchor := parent.

                ]

            ].

            anchor notNil ifTrue:[

                self expandItem:anchor do:[anchor expand]

            ]

        ].

    ]

! !

!SelectionInTree methodsFor:'accessing-behavior'!

childrenAction

    "get children action block

    "

    ^childrenAction

!

childrenAction:aBlock

    "set children action block

    "

    childrenAction := aBlock.

!

contentsAction

    "get contents action block

    "

    ^contentsAction

!

contentsAction:aBlock

    "set contents action block

    "

    contentsAction := aBlock.

!

iconAction

    "get icon action block

    "

    ^iconAction

!

iconAction:aBlock

    "set icon action block

    "

    iconAction := aBlock.

!

labelAction

    "get label action block

    "

    ^labelAction

!

labelAction:aBlock

    "set label action block

    "

    labelAction := aBlock.

!

showRoot

    "list with or without root

    "

    ^ showRoot

!

showRoot:aState

    "list with or without root

    "

    aState ~~ showRoot ifTrue:[

        showRoot := aState.

        root notNil ifTrue:[

            aState ifTrue:[

                list addFirst:root.

                self changed:#insertCollection: with:(Array with:1 with:1 with:nil).

            ] ifFalse:[

                list removeFirst.

                self changed:#removeFrom: with:(Array with:1 with:1 with:nil).

            ].

        ].

    ].

! !

!SelectionInTree methodsFor:'accessing-hierarchy'!

collapse:something 

    "collapse a node or collection of nodes

    "

    |listChanged|

    listChanged := false.

    self each:something do:[:aNode|

        aNode isCollapsable ifTrue:[

            aNode collapse.

            listChanged := true

        ]

    ].

    listChanged ifTrue:[

        self listFromRoot.

        self changed:#list.

    ]

!

expand

    "expand the root

    "

    self expand:root

!

expand:something 

    "expand a node or collection of nodes

    "

    |listChanged|

    listChanged := false.

    self each:something do:[:aNode|

        aNode isExpandable ifTrue:[

            aNode expand.

            listChanged := true

        ]

    ].

    listChanged ifTrue:[

        self listFromRoot.

        self changed:#list.

    ]

! !

!SelectionInTree methodsFor:'accessing-hierarchy new'!

doCollapse:something

    "collapse all children under an item or a sequence of items;

     if the list changed, notifications are raised

    "

    self each:something do:[:anItem|

        self collapseItem:anItem do:[ anItem collapse ]

    ]

!

doCollapseAll:something

    "collapse all children and subChildren under an item or sequence of items;

     if the list changed, notifications are raised

    "

    self each:something do:[:anItem|

        self collapseItem:anItem do:[ anItem collapseAll ]

    ]

!

doExpand:something

    "expand all children under an item or collection of items;

     if the list changed, notifications are raised

    "

    self each:something do:[:anItem|

        self expandItem:anItem do:[anItem expand]

    ]

!

doExpandAll:something

    "expand all children and subChildren under an item or sequence of items;

     if the list changed, notifications are raised

    "

    self each:something do:[:anItem|

        self expandItem:anItem do:[anItem expandAll]

    ]

! !

!SelectionInTree methodsFor:'adding & removing'!

add:something after:aChild

    "add a node or collection of nodes to parent after a child

    "

    "add a node or collection of nodes to after a child

    "

    |p|

    (aChild notNil and:[(p := aChild parent) notNil]) ifTrue:[

        self add:something afterIndex:(p indexOfChild:aChild) below:p

    ]

!

add:something afterIndex:anIndex below:aParent

    "add a node or collection of nodes to parent after an index

    "

    self add:something beforeIndex:(anIndex + 1) below:aParent

!

add:something before:aChild

    "add a node or collection of nodes to before a child

    "

    |p|

    (aChild notNil and:[(p := aChild parent) notNil]) ifTrue:[

        self add:something beforeIndex:(p indexOfChild:aChild) below:p

    ]

!

add:something beforeIndex:anIndex below:aParent

    "add a node or collection of nodes to aParents children

     before anIndex (which is a child-index)

    "

    |children start index size pList|

    (    aParent isNil

     or:[something isNil

     or:[(something isCollection and:[something isEmpty])]]

    ) ifTrue:[

        ^ self

    ].

    (start := self indexOf:aParent) == 0 ifTrue:[

        "/

        "/ parent not visible; list not changed

        "/

        aParent == root ifFalse:[

            aParent add:something beforeIndex:anIndex.

          ^ self

        ]

    ] ifFalse:[

        aParent shown ifFalse:[

            aParent add:something beforeIndex:anIndex.

            self changed:#at: with:start.

            ^ self

        ]

    ].

    children := aParent children.

    (children isEmpty or:[anIndex <= 1]) ifTrue:[

        index := 1.

    ] ifFalse:[

        size  := children size.

        anIndex > size ifTrue:[

            index := size + 1.

            start := aParent numberOfAllVisibleChildren + start.

        ] ifFalse:[

            index := anIndex.

            start := (self indexOf:(children at:index)) - 1.

        ]

    ].

    aParent add:something beforeIndex:index.

    (start := start + 1) == 0 ifTrue:[

        "/

        "/ not visible

        "/

        ^ self

    ].

    pList := OrderedCollection new:2048.

    self each:something do:[:aNode|

        pList add:aNode.

        aNode addVisibleChildrenTo:pList

    ].

    pList isEmpty ifTrue:[

        ^ self

    ].

    list addAll:pList beforeIndex:start.

    self changed:#insertCollection:

            with:(Array with:start with:pList size with:aParent).

!

add:something below:aParent

    "add a node or collection of nodes to parent

    "

    aParent notNil ifTrue:[

        self add:something beforeIndex:(aParent numberOfChildren + 1) below:aParent

    ]

!

remove:something

    "remove a node or collection of nodes

    "

    |node index loNums loItem start size parent stop|

    something isNil ifTrue:[

        ^ something

    ].

    loNums := SortedCollection new.

    self each:something do:[:el|

        node := el isNumber ifTrue:[list at:el ifAbsent:nil]

                           ifFalse:[el].

        node notNil ifTrue:[

            self stopIndicatorValidationFor:node.

            node parent isNil ifTrue:[

                "/ remove all including root

                node == root ifTrue:[ self root:nil ].

              ^ something

            ].

            index := self indexOf:node.

            index == 0 ifTrue:[

                "/ not visible

                node parent removeChild:node

            ] ifFalse:[

                loNums add:index

            ].

        ]

    ].

    loNums isEmpty ifTrue:[

        "/ nothing visible changed

        ^ something

    ].

    loItem := OrderedCollection new.

    loNums do:[:i| loItem add:(list at:i)].

    loItem do:[:aNode|

        start := self indexOf:aNode.

        start ~~ 0 ifTrue:[

            parent := aNode parent.

            size   := 1 + aNode numberOfAllVisibleChildren.

            stop   := start + size - 1.

            parent remove:aNode.

            list removeFromIndex:start toIndex:stop.

            self changed:#removeFrom:

                    with:(Array with:start with:stop with:parent).

        ]

    ].

    ^ something

!

removeAllOtherThanRoot

    "remove all other than the root

    "

    |listChanged|

    root notNil ifTrue:[

        listChanged := root isCollapsable.

        root children:(OrderedCollection new).

        listChanged ifTrue:[

            self listFromRoot.

            self changed:#list

        ]

    ]

!

removeIndex:something

    "remove a node at index or collection of indexed nodes

    "

    self remove:something

!

removeSelection

    "remove selected nodes

    "

    |sel|

    sel := self selectionIndex.

    self selectionIndex:nil.

    self remove:sel.

!

replaceNode:aNode with:aNewNode

    "replace a node by a new node; if the new node is nil, the node and its

     children are removed. Otherwise the children are taken over to the new

     node.

    "