"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1995 by 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:libview2' }"

"{ NameSpace: Smalltalk }"

Model subclass:#ApplicationModel

	instanceVariableNames:'builder resources device masterApplication'

	classVariableNames:'DefaultExtents DefaultLabels DefaultVisuals

		RecentlyOpenedApplications'

	poolDictionaries:''

	category:'Interface-Framework'

!

ApplicationModel class instanceVariableNames:'ClassResources'

"

 No other class instance variables are inherited by this class.

"

!

!ApplicationModel class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1995 by 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

"

    Since many ST-80 classes are subclasses of ApplicationModel, this class

    is provided here to allow easier porting of ST-80 code.

    It does not (currently) provide all functionality and is NOT

    compatible to the corresponding ST80 class; therefore, manual

    changes have to be made to get those applications to run under ST/X.

    (but at least, this enables you to fileIn that code and have a superclass

     for them)

    As time goes by, ST/X applications are going to be converted to

    become subclasses of this abstract class - see Launcher for a

    first concrete example.

    ApplicationModel is prepared to build a view from a windowSpec, as

    created by the windowBuilder. If your subclass does not provide such

    a spec, you should at least redefine:

        #openInterface   - to create a topview and open it

    you may want to redefine:

        #closeRequest    - to catch window closing

        #focusSequence   - to define a sequence for focus-stepping

    Once the interfaceBuilder is finished & released, subclasses can

    alternatively provide the spec via a #windowSpec method.

    The classResources have been put into this class to allow ST/X

    applications (which used to be subclasses of StandardSystemView)

    to migrate smoothly into ApplicationModels (which is better design ...).

    [Instance variables:]

        resources    ResourcePack       language string translation

        builder      WindowBuilder      a builder who knows how to create

                                        a window hierarchy from a specification

    Notice: this class was implemented using protocol information

    from alpha testers and PD code - it may not be complete or compatible to

    the corresponding ST-80 class. If you encounter any incompatibilities,

    please forward a note to the ST/X team.

    [author:]

        Claus Gittinger

    [see also:]

        StandardSystemView

        WindowGroup DeviceWorkstation

"

!

howToDealWithMultipleApplicationInstances

"

    The following relates to StandAlone applications (i.e. compiled exe's) only.

    If the user attempts to open another of the applications documents (after the first instance

    of the application has already been opened), it is sometimes required to notify the first

    application about this and to ask it to open an extra window on the second-clicked document.

    In other words: to get another of the first instances' windows instead of opening a window

    by the second application.

    This is implemented via the following mechanism (see StandaloneStartup):

        the first application instance leaves the information about its existence somewhere

            (under win32: in the registry, the window-ID of its main window is remembered;

             under unix, its stored into a locked file).

        a mutex is created to prevent a race on this informationduring startup

            (under win32: a mutex proper; under unix, the above locked file will do)

    when the app is started the second time, it will not be able to acquire the mutex (and therefore

    knows, that its the second instance). It will then send an event-message (win32: via copyData;

    unix. via sendClientEvent), to the first instance and pass the fileName of the document which

    is to be opened. The first instance receives this event and opens another window for it.

    The second instance simply exits and stops execution.

    This guarantees that only one instance of an application is executing (if desired).

    The implementation is found in:

        StandaloneStartup:

            checkForAndExitIfAnotherApplicationInstanceIsRunning

        here:

            processOpenPathCommand:aFilename

    By default, the event is ignored - subclasses which want to support that behavior MUST

    redefine processOpenPathCommand: in ApplicationModel and also make sure that

    checkForAndExitIfAnotherApplicationInstanceIsRunning is called for in StandaloneStartup.

"

! !

!ApplicationModel class methodsFor:'initialization'!

initialize

    self == ApplicationModel ifTrue:[

        Smalltalk addDependent:self

    ].

    DefaultLabels isNil ifTrue:[

        DefaultLabels := IdentityDictionary new

    ].

    DefaultVisuals isNil ifTrue:[

        DefaultVisuals := IdentityDictionary new

    ].

    "

     ApplicationModel initialize

    "

    "Modified: 28.1.1997 / 12:31:38 / cg"

! !

!ApplicationModel class methodsFor:'instance creation'!

new

    "return a new initialized instance"

    ^ self basicNew basicInitialize; initialize; yourself.

!

onDevice:aDevice

    "return a new initialized instance, which shall open its interface on aDevice."

    ^ (super basicNew basicInitialize setDevice:aDevice) initialize

! !

!ApplicationModel class methodsFor:'accessing'!

application

    ^ self

!

applicationName

    "the name as shown in an about box or in the deployed package.

     If there is an application definition in my package, ask that one.

     Otherwise, return my name."

    |prjDef|

    (prjDef := self projectDefinitionClass) notNil ifTrue:[

        prjDef isApplicationDefinition ifTrue:[

            ^ prjDef applicationName

       ]. 

    ].

    ^ self name

! !

!ApplicationModel class methodsFor:'active help'!

flyByHelpSpec

    "obsolete: only provided for backward compatibility.

     default is: take the oldStyle help-spec (should be redefined by concrete class)."

    ^ self helpSpec

!

helpSpec

    "default is: no help-spec (should be redefined by concrete class if help is wanted)."

    ^ IdentityDictionary new.

! !

!ApplicationModel class methodsFor:'bindings'!

actionFor:aKey

    "sent by the builder to ask for an actionBlock for

     a Button. The argument, aKey comes from an UI-spec

     for a buttons #action property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     actionBlocks from a Dictionary or whatever.

     Typically, a block is returned there."

    ^ nil

!

actionFor:aKey withValue:aValue

    "sent by the builder to ask for an actionBlock for

     a Button which passes a value to the actionMethod.

     The argument, aKey comes from an UI-spec

     for a buttons #action property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     actionBlocks from a Dictionary or whatever.

     Typically, a block is returned there."

    ^ nil

!

aspectFor:aKey

    "sent by the builder to ask for an aspect (a data model).

     The argument, aKey comes from an UI-spec

     for a components #aspect property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     holders from a Dictionary or whatever.

     Typically, a valueHolder is returned there."

    ^ self perform:aKey

    "/ ^ nil

    "Modified: / 27.10.1997 / 13:43:12 / cg"

!

clientFor:aKey

    "sent by the builder to ask for an application provided

     subcanvas's application.

     The argument, aKey comes from an UI-spec

     for a subcanvas's #client property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     appModels from a Dictionary or whatever.

     Typically, an applicationModel is returned there."

    ^ nil

!

colorFor:aSymbol

    "sent by the builder to ask for an application provided color.

     The argument, aKey comes from an UI-spec

     for a widgets #*Color property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     holders from a Dictionary or whatever.

     Typically, a color is returned there."

    (self respondsTo:aSymbol) ifTrue:[

        ^ (self perform:aSymbol) value.

    ].

    "fall back to a possibly well defined color name"

    ^ Color name:aSymbol ifIllegal:nil.

!

componentFor:aKey

    "sent by the builder to ask for an application provided

     component.

     The argument, aKey comes from an UI-spec

     for a viewHolders #view property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     holders from a Dictionary or whatever.

     Typically, a view is returned there."

    (self respondsTo:aKey) ifTrue:[

        ^ self perform:aKey

    ].

    ^ nil

!

fontFor:aSymbol

    "sent by the builder to ask for an application provided font.

     The argument, aKey comes from an UI-spec

     for a widgets #*Font property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     holders from a Dictionary or whatever.

     Typically, a font is returned there."

    (self respondsTo:aSymbol) ifTrue:[

        ^ self perform:aSymbol.

    ].

"/    "fall back to a well defined font name"

"/    (Font respondsTo:aSymbol) ifTrue:[

"/        ^ Font perform:aSymbol.

"/    ].

    ^ nil

!

labelFor:aKey

    "sent by the builder to ask for an application provided

     label for a component.

     The argument, aKey comes from an UI-spec

     for a components #label property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     labels from a Dictionary or whatever.

     Typically, a string is returned there."

    |app|

    app := self application.

    app isNil ifTrue:[^ nil].

    (app respondsTo:aKey) ifTrue:[

        ^ app perform:aKey

    ].

    ^ app labelAt:aKey ifAbsent:nil

!

listFor:aKey

    "sent by the builder to ask for an application provided

     holder for a list.

     The argument, aKey comes from an UI-spec

     for a listWidgets #list property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     holders from a Dictionary or whatever.

     Typically, a list-holding model (SelectionInList) is returned there."

    |app|

    app := self application.

    app notNil ifTrue:[

        (app respondsTo:aKey) ifTrue:[

            ^ app perform:aKey

        ]

    ].

    ^ nil.

    "Modified: 4.3.1997 / 00:53:03 / cg"

!

menuFor:aKey

    "sent by the builder to ask for an application provided

     holder for a menu.

     The argument, aKey comes from an UI-spec

     for a widgets #menu property.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     holders from a Dictionary or whatever.

     Typically, a menu or a menu-holding valueHolder is returned there."

    ^ self application perform:aKey

!

specificationFor:aKey

    "sent by the builder to ask for an application provided

     specification for a subcanvas or subspecification.

     The argument, aKey comes from an UI-spec

     for a subcanvases #specification property (minorKey).

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     interfaceSpecifications from a Dictionary or whatever.

     Typically, an interfaceSpecification is returned there."

    ^ self

        specificationFor:aKey

        application:self

        onDevice:nil

!

specificationFor:aKey application:app onDevice:deviceOrNil

    "sent by the builder to ask for an application provided

     specification for a subcanvas or subspecification.

     The argument, aKey comes from an UI-spec

     for a subcanvases #specification property (minorKey).

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     interfaceSpecifications from a Dictionary or whatever.

     Typically, an interfaceSpecification is returned there."

    |displayDevice displayDeviceType modifiedKey appClass|

    "/ this code is so ugly...

    "/ translate the specs name, if the display device type is different

    "/ for example, if the type is pda, the xxxSpec_pda spec will be used.

    displayDevice := deviceOrNil.

    displayDevice isNil ifTrue:[

        displayDevice := Screen current.

        displayDevice isNil ifTrue:[

            displayDevice := Screen default.

        ]

    ].

    displayDevice notNil ifTrue:[

        displayDeviceType := displayDevice deviceType.

        displayDeviceType notNil ifTrue:[

            modifiedKey := (aKey , '_' , displayDeviceType) asSymbolIfInterned.

            modifiedKey notNil ifTrue:[

                (app respondsTo:modifiedKey) ifTrue:[

                    ^ app perform:modifiedKey

                ].

                app isBehavior ifFalse:[

                    appClass := app application.

                    (appClass respondsTo:modifiedKey) ifTrue:[

                        ^ appClass perform:modifiedKey

                    ].

                ].

            ]

        ]

    ].

    app isBehavior ifFalse:[

        (app respondsTo:aKey) ifTrue:[

            ^ app perform:aKey

        ].

        appClass := app application.

        (appClass respondsTo:aKey) ifTrue:[

            ^ appClass perform:aKey

        ].

        ^ app masterApplication specificationFor:aKey

    ].

    ^ app perform:aKey

    "Modified: / 18-07-2011 / 09:28:15 / cg"

!

subApplicationFor:aKey

    "sent by subCanvas to ask for an application inside itself.

     The argument, aKey comes from a TabList-specs majorKey.

     Here, a corresponding message is sent to myself,

     which ought to be defined in the application subclass.

     Alternatively, a subclass may redefine this method, to provide

     an application from a Dictionary or whatever.

     Typically, an ApplicationModel subinstance is returned there."

    |app|

    app := self application.

    (app respondsTo:aKey) ifTrue:[

        ^ app perform:aKey

    ].

    ^ nil

!

visualFor:aKey

    "sent by the builder to ask for an application provided