"

 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.

"

"{ Package: 'stx:libwidg2' }"

HierarchicalList subclass:#HierarchicalFileList

	instanceVariableNames:'matchBlock indicatorList indicatorTask sortBlock'

	classVariableNames:''

	poolDictionaries:''

	category:'Views-Support'

!

HierarchicalItem subclass:#HierarchicalFileItem

	instanceVariableNames:'icon contentsItem'

	classVariableNames:'LastUIDToUserNameMapping LastGIDToGroupNameMapping'

	poolDictionaries:''

	privateIn:HierarchicalFileList

!

HierarchicalFileList::HierarchicalFileItem subclass:#File

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:HierarchicalFileList

!

HierarchicalFileList::HierarchicalFileItem subclass:#Directory

	instanceVariableNames:'modificationTime makeIconGray quickChildrenInfo'

	classVariableNames:'StateUnknown StateHasChildren StateHasNoChildren StateFetching'

	poolDictionaries:''

	privateIn:HierarchicalFileList

!

HierarchicalFileList::Directory subclass:#RemoteDirectory

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:HierarchicalFileList

!

!HierarchicalFileList 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.

"

!

examples

"

    open filebrowser without monitoring cycle

                                                                    [exBegin]

    |top sel list directory|

    list := HierarchicalFileList new.

    list showRoot:false.

    list matchBlock:[:fn :isDir| true ].

    directory := Filename currentDirectory.

    directory := Filename homeDirectory.

    list directory:(directory asAbsoluteFilename).

    top := StandardSystemView new; extent:300@300.

    sel := ScrollableView for:HierarchicalListView miniScroller:true

                       origin:0.0@0.0 corner:1.0@1.0 in:top.

    sel doubleClickAction:[:i| (list at:i) toggleExpand ].

    sel   indicatorAction:[:i| (list at:i) toggleExpand ].

    sel hasConstantHeight:true.

    sel list:list.

    top open.

                                                                [exEnd]

    open filebrowser and monitore contents

                                                                    [exBegin]

    |top sel list directory|

    list := HierarchicalFileList new.

    list showRoot:false.

    list matchBlock:[:fn :isDir| true ].

    directory := Filename currentDirectory.

    directory := Filename homeDirectory.

    list directory:(directory asAbsoluteFilename).

    top := StandardSystemView new; extent:300@300.

    sel := ScrollableView for:HierarchicalListView miniScroller:true

                       origin:0.0@0.0 corner:1.0@1.0 in:top.

    sel doubleClickAction:[:i| (list at:i) toggleExpand ].

    sel   indicatorAction:[:i| (list at:i) toggleExpand ].

    sel hasConstantHeight:true.

    sel list:list.

    list monitoringTaskDelay:0.5.

    top open.

                                                                [exEnd]

"

! !

!HierarchicalFileList class methodsFor:'helpers'!

forInfoItem:aItem

    "instance creation helper

    "

    | info fileType retItem|

    info := aItem info.

    fileType := aItem type.

    retItem := self itemFor:aItem fileName fileType:fileType.

    retItem fileInfo:info.

    ^ retItem

!

itemFor:aFileOrDirectoryName fileType:fileType

    "instance creation helper

    "

    fileType == #directory ifTrue:[

        ^ Directory fileName:aFileOrDirectoryName.

    ].

    fileType == #remoteDirectory ifTrue:[

        ^ RemoteDirectory fileName:aFileOrDirectoryName.

    ].

    ^ File fileName:aFileOrDirectoryName.

! !

!HierarchicalFileList methodsFor:'accessing'!

directory

    "returns the root directory or nil"

    ^ root notNil ifTrue:[root fileName] ifFalse:[nil]

!

directory:aDirectory

    "set the root directory or nil"

    self directory:aDirectory expand:true

!

directory:aDirectory expand:doExpand

    "set the root directory or nil; 

     reuse old items if existent"

    |oldDir newDir oldRoot newRoot index changeToParent children|

    (     aDirectory isNil

     or:[(newDir := aDirectory asFilename) exists not]

    ) ifTrue:[

        self root:nil.

        ^ self

    ].

    newDir isDirectory ifFalse:[

        newDir := newDir directory

    ].

    newDir := newDir asCanonicalizedFilename.

    oldDir := self directory.

    oldDir = newDir ifTrue:[^ self].

    oldRoot := root.

    changeToParent := false.

    oldDir notNil ifTrue:[

        oldDir directory = newDir ifTrue:[

            changeToParent := true.

        ] ifFalse:[

            "search for existing item

            "

            self do:[:el|

                el fileName = newDir ifTrue:[

                    el parent:nil.

                    self root:el.

                    doExpand ifTrue:[ el expand ].

                    ^ self

                ].

            ].

        ].

    ].

    newRoot := HierarchicalFileItem fileName:newDir.

    newRoot setExpanded:false.  "/ to supress change notifications

    self root:newRoot.

    children := newRoot children ? #().

    "/ disable <cd ..> handling

    changeToParent := false.

    changeToParent ifTrue:[

        index := children findFirst:[:el| el fileName = oldDir ].

        index ~~ 0 ifTrue:[ newRoot at:index put:oldRoot ].

    ].

    doExpand ifTrue:[ newRoot enforcedExpand ].

!

root:aRoot

    self criticalDo:[

        indicatorList notNil ifTrue:[

            indicatorList do:[:el| el resetFetchIndicator ].

            indicatorList removeAll.

        ]

    ].

    aRoot notNil ifTrue:[

        self showRoot ifFalse:[aRoot setExpanded:true ]

    ].

    ^ super root:aRoot

! !

!HierarchicalFileList methodsFor:'actions'!

matchBlock

    "set the matchBlock - if non-nil, it controls which files are visible."

    ^ matchBlock

!

matchBlock:aBlock

    "set the matchBlock - if non-nil, it controls which files are visible."

    matchBlock := aBlock.

    root notNil ifTrue:[

        self recursionLock critical:[

            self stopMonitoringTask.

            root matchBlockChanged.

        ].

        self startMonitoringTask.

    ].

!

sortBlock

    sortBlock notNil ifTrue:[ ^ sortBlock ].

    sortBlock := [:a :b| |aIsDir entry1 entry2 ignoreCase|

        ignoreCase := Filename isCaseSensitive not.

        aIsDir := a isDirectory.

        aIsDir == b isDirectory  

            ifTrue:[

                entry1 := a fileName name.

                entry2 := b fileName name.

                ignoreCase ifTrue:[

                    entry1 := entry1 asLowercase.

                    entry2 := entry2 asLowercase.

                ].

                entry1 <= entry2.

            ]

            ifFalse:[aIsDir].

    ].

    ^ sortBlock

    "Modified: / 13-12-2006 / 15:38:45 / User"

!

sortBlock:aBlock

    sortBlock := aBlock.

    root notNil ifTrue:[

        self recursionLock critical:[

            self stopMonitoringTask.

            root recursiveSort:aBlock.

        ].

        self startMonitoringTask.

    ].

! !

!HierarchicalFileList methodsFor:'private-monitoring task'!

monitoringCycle

    self monitoringCycle:false

!

monitoringCycle:update

    "the action performed by the monitoring task; 

     tests whether directory is expanded;

     otherwise we do not have to evaluate the directory contents.

     TODO: Think about remote file-systems"

    |index item|

    item := root.

    item isNil ifTrue:[^ self].

    self showRoot ifTrue:[ index := 2 ]         "/ root is  part of list (discard first entry)

                 ifFalse:[ index := 1 ].        "/ root not part of list

    [item notNil] whileTrue:[

        dependents size == 0 ifTrue:[ ^ self ].

        item isDirectory ifTrue:[

            update ifTrue:[

                item modificationTime:nil.

            ]. 

            item monitoringCycle

        ].

        "/ Processor yield.

        item  := self at:index ifAbsent:nil.

        index := index + 1.

    ].

! !

!HierarchicalFileList methodsFor:'protocol'!

childrenFor:anItem

    "returns all visible children derived from the physical

     directory contents."

    |contents list matchBlock|

    anItem isDirectory ifFalse:[^ #()].

    contents := DirectoryContents directoryNamed:anItem fileName.

    contents isNil ifTrue:[ ^ #() ].

    list := OrderedCollection new.

    matchBlock := self matchBlockFor:anItem.

    contents itemsDo:[:anItem|

        (matchBlock isNil or:[matchBlock value:(anItem fileName) value:(anItem isDirectory)]) ifTrue:[

            list add:(HierarchicalFileItem forContentsItem:anItem).

        ]

    ].

    list isEmpty ifTrue:[^ #()].

    list sort:self sortBlock.

    ^ list

!

hasChildrenFor:anItem

    "returns true if the physical directory contains at least

     one visible item; otherwise false."

    |block|

    anItem isDirectory ifFalse:[

        ^ false

    ].

    (block := self matchBlockFor:anItem) isNil ifTrue:[

        block := [:aFilename :isDirectory| true ]

    ].

    ^ DirectoryContents directoryNamed:(anItem fileName) detect:block

!

matchBlockFor:anItem

    "get the matchBlock - if non-nil, it controls which files are

     visible within the physical directory"

    ^ matchBlock        

!

updateList

    self monitoringCycle:true

! !

!HierarchicalFileList methodsFor:'searching'!

findLastForFile:aPathOrFile

    "find last item which matches the path or file

     returns the item or nil if not contained in self"

    |file searchItem rootDir rootComponents searchComponents|

    (aPathOrFile isNil or:[root isNil]) ifTrue:[

        ^ nil

    ].

    file := aPathOrFile asFilename.

    file exists ifFalse:[ ^ nil ].

    rootDir := root fileName asAbsoluteFilename.

"/    file    := file asAbsoluteFilename.

"/    (file pathName startsWith:(rootDir pathName)) ifFalse:[

    (file asString startsWith:(rootDir pathName)) ifFalse:[

        "not included"

        ^ nil

    ].

    rootComponents   := rootDir components.

    searchComponents := file asCanonicalizedFilename components.

    searchItem       := root.

    searchComponents from:(rootComponents size + 1) do:[:aName| |child|

        child := searchItem detect:[:el| el baseName = aName ] ifNone:nil.

        child isNil ifTrue:[ ^ searchItem ].

        searchItem := child.

    ].

    ^ searchItem

! !

!HierarchicalFileList methodsFor:'update'!

startIndicatorValidationFor:anItem

    "an item will be registered for an indication update"

    |prio|

    self criticalDo:[

        indicatorList size == 0 ifTrue:[

            indicatorList := OrderedCollection new.

        ] ifFalse:[

            indicatorList removeIdentical:anItem ifAbsent:nil.

        ].

        "/ indicatorList addFirst:anItem.

        indicatorList add:anItem.

        indicatorTask isNil ifTrue:[

            prio := Processor activePriority.

            indicatorTask := 

                [ 

                    self updateIndicatorCycle. 

                ] newProcess.

            indicatorTask priorityRange:(prio-1 to:prio).

            indicatorTask resume.

        ]

    ].

!

stopIndicatorValidationFor:anItem

    "stop the indicator validation for an item"

    self criticalDo:[

        indicatorList notNil ifTrue:[

            indicatorList removeIdentical:anItem ifAbsent:nil.

            anItem resetFetchIndicator.

        ]

    ].

!

updateIndicatorCycle

    "run fetching indicator (hasChildren info) task cycle.

     This is done in the background to avoid long startup

     delays, in case the indicator information takes long to

     gather (i.e. when reading remote directories)"

    |repeat task item|

    repeat := true.

    task   := indicatorTask.

    [ 

        [ task notNil ] whileTrue:[

            self criticalDo:[

                (     dependents    size ~~ 0       "/ no dependencies (stop task)

                 and:[indicatorList size ~~ 0]      "/ nothing to do

                ) ifTrue:[

                    item := indicatorList removeFirst.

                    (self includesIdentical:item) ifFalse:[

                        "/ item is no longer visible

                        item resetFetchIndicator.

                        item := nil

                    ]

                ] ifFalse:[

                    item := indicatorTask := task := nil

                ]

            ].

            item notNil ifTrue:[

                item fetchIndicator.