"

 COPYRIGHT (c) 1993 by Claus Gittinger

 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.

"

Dictionary subclass:#ResourcePack

!

ResourcePack comment:'

COPYRIGHT (c) 1993 by Claus Gittinger

'!

!ResourcePack class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 by Claus Gittinger

 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.

"

!

version

"

"

!

documentation

"

    to allow easy customization of smalltalk code (i.e. internationalization)

    (replaces the obsolete Resource class).

    ResourcePacks are class specific, meaning that every subclass of view

    has an instance of ResourcePack (called resources) which is created when

    the first instance of the view is created.

    The resourcePack consists of a mapping from strings to values, which are

    then used in labels, buttons, menus etc.

    The resourcePack initializes itself from a file found in 'resources/<className>.rs',

    where 'className' is built by the usual abbreviation mechanism (see abbrev-files).

    Conditional mappings are possible, by including lines as:

    in the resourcefile. Example:

    file 'foo.rs':

    the corresponding resource-strings are accessed using:

    returning the mapped string (i.e. 'Abbruch' if the global Language is set

    to #german)..

    If no corresponding entry is found in the resources, the key is returned.

    Translations can also include arguments, such as:

"

! !

!ResourcePack class methodsFor:'initialization'!

initialize

    Packs isNil ifTrue:[

    ].

    "ResourcePack initialize"

!

    "forget all cached resources - needed after a style change"

    Packs := nil.

    self initialize

! !

!ResourcePack class methodsFor:'private'!

addToCache:aPack

    |idx|

    idx := Packs identityIndexOf:nil.

    idx == 0 ifTrue:[

    ].

    Packs at:idx put:aPack

!

searchCacheFor:aClassname

    |sz|

    Packs isNil ifTrue:[

    ].

    sz := Packs size.

    1 to:sz do:[:idx |

    ].

    ^ nil

! !

!ResourcePack class methodsFor:'instance creation'!

fromFile:aFileName directory:dirName

    "get the resource definitions from a file in a directory.

     Uncached low-level entry."

    newPack := self new.

    ^ newPack

!

fromFile:aFileName

    "get the resource definitions from a file in the default directory.

     Uncached low-level entry."

    ^ self fromFile:aFileName directory:'resources'

    "

     ResourcePack fromFile:'SBrowser.rs'

     ResourcePack fromFile:'FBrowser.rs'

     ResourcePack fromFile:'Smalltalk.rs'

    "

!

for:aClass

    "get the full resource definitions for aClass (i.e. with super packs).

     Also leave the resulting pack in the cache for faster access next time."

    |nm pack superPack|

    nm := aClass name.

    pack := self searchCacheFor:nm.

    pack notNil ifTrue:[^ pack].

    pack := self fromFile:(Smalltalk fileNameForClass:nm) , '.rs'.

    aClass == Object ifFalse:[

    ].

    pack packsClassName:nm.

    self addToCache:pack.

    ^ pack

! !

!ResourcePack methodsFor:'merging'!

merge:anotherPack

    anotherPack keysAndValuesDo:[:key :value |

    ]

! !

!ResourcePack methodsFor:'accessing'!

dependents:aCollection

    dependents := aCollection

!

dependents

    ^ dependents

!

packsClassName

    ^ packsClassName

!

packsClassName:aString

    packsClassName := aString

!

at:aKey

!

at:aKey default:default

!

name:aKey

!

name:aKey default:default

!

array:anArray

    ^ anArray collect:[:r | self at:r default:r]

!

string:s

!

string:s with:arg

    ^ self string:s withArgs:(Array with:arg)

!

string:s with:arg1 with:arg2

    ^ self string:s withArgs:(Array with:arg1 with:arg2)

!

string:s withArgs:argArray

    | template expandedString idx start stop next |

    template := self at:s ifAbsent:[s].

    expandedString := ''.

    stop := template size.

    start := 1.

    [start < stop] whileTrue:[

    ].

    ^  expandedString

! !

!ResourcePack methodsFor:'file reading'!

    ifLevel := 0.

    skipping := false.

    [inStream atEnd] whileFalse:[

    ].

! !

ResourcePack initialize!