Smalltalk/X Webserver

Documentation of class 'ApplicationModel':

Class: ApplicationModel

Inheritance
Description
Related information
Class protocol
Instance protocol

Inheritance:

   Object
   |
   +--Model
      |
      +--ApplicationModel
         |
         +--AbstractFileApplicationNoteBookComponent
         |
         +--AbstractFileBrowser
         |
         +--AbstractLoggerSettingsApplication
         |
         +--AbstractSettingsApplication
         |
         +--DidYouKnowTipViewer
         |
         +--Dolphin::Shell
         |
         +--MemoryMonitor
         |
         +--MultipleItemSelectionWidget
         |
         +--PrintAbortDialog
         |
         +--PrintingDialog
         |
         +--ProcessMonitorV2
         |
         +--SettingsDialog
         |
         +--SimpleDialog
         |
         +--SystemBrowser
         |
         +--ToolApplicationModel
         |
         +--Tools::BreakpointBrowser
         |
         +--Tools::NavigatorModel
         |
         +--Tools::SpecialCodeView
         |
         +--Tools::StringSearchTool
         |
         +--URITransmissionServiceAppl
         |
         +--URITransmissionServiceAppl::URIDialog
         |
         +--VersionDiffBrowser

Package:: stx:libview2

Category:: Interface-Framework

Version:: rev: 1.301 date: 2010/04/09 10:53:48; user: stefan; file: ApplicationModel.st directory: libview2; module: stx stc-classLibrary: libview2

Author:: Claus Gittinger

Description:

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.

Related information:

    StandardSystemView
    WindowGroup
    DeviceWorkstation

Class protocol:

accessing

application

active help

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

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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
visualFor: aKey: sent by the builder to ask for an application provided
image or element for a label.
The argument, aKey comes from an UI-spec
for a widgets #label property, if LabelIsImage is turned on.
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
images from a Dictionary or whatever.
Typically, an image is returned there.

change & update

update: something with: aParameter from: changedObject: flush resources on language changes

defaults

defaultHttpServerPort: this is only used for web-applications
defaultIcon: default is: no icon (should be redefined by concrete class if an icon is wanted).
defaultIconForAboutBox: the icon to be shown in my about-this-app dialog
defaultServiceLinkName: old web server interface - remove me

** This is an obsolete interface - do not use it (it may vanish in future versions) **
labelAt: aKey: default is: no label (could be redefined by concrete class ).
labelAt: aKey ifAbsent: aBlock: default is: no label (could be redefined by concrete class ).
labelAt: aKey put: aValue: not yet implemented
labels: not yet implemented
visualAt: aKey: default is: no visual (could be redefined by concrete class ).
visualAt: aKey ifAbsent: aBlock: default is: no visual (could be redefined by concrete class ).
visualAt: aKey put: aValue: not yet implemented
visuals: not yet implemented

help

aboutImage: bitmap image or nil for an about box for this application.
aboutThisApplicationLabel: label for an about box for this application.
aboutThisApplicationText: text for an about box for this application.
documentationPath

history

forgetRecentlyOpenedApplications
recentlyOpenedApplications
rememberRecentlyOpenedApplication

initialization

initialize

instance creation

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

private

selfResponsibleFor: aKey: ** This is an obsolete interface - do not use it (it may vanish in future versions) **

queries

interfaceSpecFor: aSelector: return an interface spec
isVisualStartable: return true, if this application can be started via #open.
(to allow start of a change browser via double-click in the browser)

resources

classResources: if not already loaded, get the classes resourcePack and return it
classResources: aResourcePack: allow setting of the classResources
flushAllClassResources: flush all classes resource translations.
Needed after a resource file / language setting has changed.
flushClassResources: flush classes resource string translations.
Needed whenever a resource file / language setting has changed
resources: return the applications resources -
that's a ResourcePack containing national language strings
updateClassResources: update my classResources

startup

open: create an instance of the application and open its view
openAt: aLocation: create an instance of the application and open its view
at some position.
openDialogInterface: anInterfaceSymbol: create an instance of the application and open a view as
specified by anInterfaceSymbol.
openDialogInterface: anInterfaceSymbol withBindings: bindings: create an instance of the application and open a view as
specified by anInterfaceSymbol.
openDialogInterfaceSpec: anInterfaceSpec: create an instance of the application and open a view as
specified by the given spec.
openDialogInterfaceSpec: anInterfaceSpec withBindings: bindings: create an instance of the application and open a view as
specified by the given spec.
openDialogSpec: aSpec: create an instance of the application and open a view as
specified by aSpec.
openDialogSpec: aSpec withBindings: bindings: create an instance of the application and open a view as
specified by the spec.
openInterface: anInterfaceSymbol: create an instance of the application and open a view as
specified by anInterfaceSymbol.
openInterface: anInterfaceSymbol at: aPoint: create an instance of the application and open a view as
specified by anInterfaceSymbol.
openModal: create an instance of the application and open its view modal
openOn: anApplicationModel: send an open message to the argument, anApplicationModel.
I dont really understand what this method is useful for ...
openOnDevice: aDevice: create an instance of the application and open its view
on ANOTHER device.
For more info, read the document on multiple display
support and the documentation of the DeviceWorkstation class.
openOnXScreenNamed: aScreenName: create an instance of the application and open its view
on some X display screen. The argument aScreenName must be
a valid x-display name (i.e. of the form '<host>:<screenNr>' as in 'foo:0').
For more info, read the document on multiple display
support and the documentation of the DeviceWorkstation class.
openWithSpec: aSpecSymbol: ST80 compatibility:
mhmh - what is the difference to #openInterface ?

startup-web applications

initialPageSpec: this is only required for web-applications

** This method raises an error - it must be redefined in concrete classes **
pageSpec: this is only used for web-applications
pageSpecs: this is only required for web-applications

** This method raises an error - it must be redefined in concrete classes **
startAsWebService: this is not yet a public interface. For internal exept use only.
Start a web service for myself on the default webService linkURL.
The webService will create new instances of me for incoming sessions.
Answer the webService.
startAsWebService: linkName: this is not yet a public interface. For internal exept use only.
Start a web service for myself on link, an URL.
The webService will create new instances of me for incoming sessions.
Answer the webService.
Start a HTTP server, if not already running
startAsWebService: linkName inServer: httpServer: this is not yet a public interface. For internal exept use only.
Start a web service for myself on the default webService linkURL.
The webService will create new instances of me for incoming sessions.
Answer the webService.
Start a HTTP server, if not already running
startAsWebService: linkName onPort: httpPort: this is not yet a public interface. For internal exept use only.
Start a web service for myself on the default webService linkURL.
The webService will create new instances of me for incoming sessions.
Answer the webService.
Start a HTTP server, if not already running
startAsWebService_old: this is not yet a public interface. For internal exept use only
startInPortalService: aPortalServiceOrSession: this is not yet a public interface. For internal exept use only
webServiceLinkName: the link name, under which instances of myself are found in the httpServer

Instance protocol:

accessing

application: application knows about interfaceSpecs, menuSpecs etc.
Usually this is my class.
This may be redefined in subclasses
builder: return the applications builder; this one has more information
about views, components etc.
builder: aBuilder: set the applications builder. Normally, you should not set it
directly, but depend on the default builder, as created when the application
was created.
componentAt: name: return a component identified by its name
device
masterApplication: return the value of the instance variable 'masterApplication' (automatically generated)
masterApplication: something: set the value of the instance variable 'masterApplication' (automatically generated)
resources: return the applications resources -
that's a ResourcePack containing national language strings
resources: aResourcePack: set the applications resources - usually this is done automatically,
except for manually built dialogs
window: return my topWindow - or nil, if I have no window (yet)
window: aTopView: set my topWindow.
As a side effect, this creates a dummy builder if non has yet
been built. This prevents non-GUI-Painter apps from failing later,
when the builder is accessed.
windowGroup: return the applications windowGroup

binding access

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.
actionFor: aKey withValue: aValue: sent by the builder to ask for an actionBlock for
a Button which passes a value.
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.
actionFor: aKey withValue: value1 withValue: value2: sent by the builder to ask for an actionBlock for a Button which passes two values.
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.
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.
aspectOrNil: aKey forSubApplication: aSubApp
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.
colorFor: aKey: 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.
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.
fontFor: aKey: 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.
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.
listFor: aKey: sent by the builder to ask for an application provided
holder for a list (for example, a popUpLists 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.
If the instance does not provide a value, a corresponding aspect
is asked for. If that fails as well, the app class is asked as a last
chance.
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.
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.
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.
visualFor: aKey: sent by the builder to ask for an application provided
image or element for a label.
The argument, aKey comes from an UI-spec
for a widgets #label property, if LabelIsImage is turned on.
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
images from a Dictionary or whatever.
Typically, an image is returned there.

binding access-help

basicFlyByHelpTextForKey: aKey: flyByHelp interface: return some short help text for a key
key is the symbol associated with some widget or menu item.
Return the original (english) text; needs to be translated as per language
basicHelpTextForKey: aKey: activeHelp interface: return some help text for a key
key is the symbol associated with some widget or menu item.
Return the original (english) text; needs to be translated as per language
flyByHelpSpec: activeHelp interface: return some short help text for a widget component
flyByHelpTextFor: aComponent: activeHelp interface: return some short help text for a widget component
flyByHelpTextForKey: aKey: flyByHelp interface: return some short help text for a key
key is the symbol associated with some widget or menu item.
(from my flyByHelpSpec); return a language variant (if available)
flyByHelpTextForKey: aKey row: aRowNr: Special interface for DataSet - get the active help text for a specific row
helpSpec: activeHelp interface: return some short help text for a widget component
helpTextFor: aComponent: activeHelp interface: return some help text for a widget component
helpTextForKey: aKey: activeHelp interface: return some help text for a key
key is the symbol associated with some widget or menu item.
(from my helpSpec); return a language variant (if available)

building

allButOpen: create my views from the windowSpec, but do not open the main window.
allButOpenFrom: aSpec: create my views but do not open the main window.
The argument is a spec which defines the interface.
allButOpenInterface: aSymbol: create my views but do not open the main window.
The argument specifies a selector of a method,
which when sent to myself should return a spec.
Notice, this returns the windowBuilder.
buildSpec: specToBuild asSubCanvasWithBuilder: aBuilder: build a subcanvases spec into aSubcanvas
buildSubCanvas: spec withBuilder: aBuilder: build a subcanvases' spec into aSubcanvas
buildSubCanvas: spec withMenu: withMenuBoolean withBuilder: aBuilder: build a subcanvases' spec into aSubcanvas

component manipulations

components: aSymbolOrArray do: aBlock: evaluate aBlock for all components listed aSymbolOrArray.
disable: aSymbolOrArray: disable the components whose id's are aSymbolOrArray.
enable: aSymbolOrArray: enables the component(s) identified by aSymbolOrArray.
invalidate: aSymbolOrArray: invalidates the component(s) identified by aSymbolOrArray.
makeInvisible: aSymbolOrArray: makes the components whose id's are aSymbolOrArray invisible
makeReadOnly: aSymbolOrArray: make all components identified by aSymbolOrArray read only
(for editText components).
makeVisible: aSymbolOrArray: makes the components whose id's are aSymbolOrArray visible
makeWritable: aSymbolOrArray: make all components identified by aSymbolOrArray writable
(for editText components).

copying

postCopy
postDeepCopy

delayed actions (enqueue)

delayedUpdate: something with: aParameter from: changedObject: support for delayed updates -
subclasses which invoke #enqueueDelayedUpdate:with:from: (from #update:with:from:)
must also redefine this method, and perform the actual update there.
enqueueDelayedAction: aBlock: This will enqueue a delayed action - the application-process will
eventually execute aBlock.
Useful for synchronization
enqueueDelayedUpdate: something with: aParameter from: changedObject: support for delayed updates - to be invoked from a concrete classes
#update:with:from: method.
This will enqueue a delayed update, and resend #delayedUpdate:with:from:
whenever the receiver is handling events.
Especially useful, if many updates arrive at high frequency, to avoid
multiple redraws.
enqueueMessage: selector for: someone arguments: argList: enqueue a message to be sent to myself later, when my process
is back in its eventLoop. Also, filter duplicates.
This is useful, to buffer redraws and avoid flicker due to multiple
redraws (especially in browsers, when reacting on changeMessages resulting
from changes made in other browsers)

drag & drop

canDropObjects: aCollectionOfDropObjects: drop manager asked if a drop is possible
- should be redefined by apps which can do it, to return true
canDropObjects: aCollectionOfDropObjects in: aComponent: drop manager asked if a drop is possible
- should be redefined by apps which can do it, to return true
canDropObjects: aCollectionOfDropObjects in: aComponent at: position: drop manager asked if a drop is possible.
Should be redefined by apps which can do it, to return true
dropObjects: aCollectionOfDropObjects: drop manager wants to drop.
This is ony sent, if #canDrop: returned true.
Must be redefine in order for drop to work.

** This method raises an error - it must be redefined in concrete classes **
dropObjects: aCollectionOfDropObjects in: aComponent: drop manager wants to drop.
This is ony sent, if #canDrop: returned true.
Must be redefine in order for drop to work.
dropObjects: aCollectionOfDropObjects in: aComponent at: aPoint: drop manager wants to drop.
This is ony sent, if #canDrop:in: returned true.
Can be redefined in apps which return true to #canDrop.
droppedFile: aFilename in: aComponent: ignored here - only sent by textView components, sometimes

easy bindings

registerInterestIn: aValueModel using: aSelectorOrArray: Register interest in a change in aValueModel using information in aSelectorOrArray.
aSelectorOrArray can be one of three things:

1) nil in which case no interest is registered
2) a selector in which case the receiver is understood to be self
3) an Array in which case the size is two where the first element is the
message to be sent and the second element is the receiver.
valueHolderFor: aSelector initialValue: anObject: Return a ValueHolder on anObject.
valueHolderFor: aSelector initialValue: anObject changeMessage: aSelectorOrArrayOrNil: Return a ValueHolder on anObject. aSelectorOrArrayOrNil is the change information
for the ValueHolder. This argument is either a Symbol or an Array of two elements.
If it is a Symbol, then it is the change message and the interested object is understood
to be the reciever. If it is an Array, then the first element is the change message and
the second element is the interested object.

forced actions

doAcceptByReturnKey
doCancelByEscapeKey

help

aboutImage: bitmap image or nil for an about box for this application.
aboutThisApplicationLabel: label for an about box for this application.
aboutThisApplicationText: text for an about box for this application.
flyByHelpDependsOnPositionIn: aView: subclasses where the help-text depends upon the pointer position might
want to redefine this
openAboutThisApplication: opens an about box for this application.
Can be specialized by redefining #aboutThisApplicationText
and #aboutThisApplicationLabel
openHelpViewOnFile: pathToHelpText: open a help viewer (as opened by the help buttons).
The argument is a relative path within the help directory
(but a file under the current directory is tried first)
showActiveHelp: aHelpText for: view: This is invoked from the activeHelp event listener, to display some popup-help
for a component. If false is returned, the help manager will pop up
some active help bubble; if true is returned, it will assume that the
help text has been already displayed and will not do any further actions.
Here, we accept the help text, and push an event into out own input
queue, so that the help text will be displayed asyncronously by myself,
vis the #showHelp:for: method.
This can be redefined in concrete classes to handle active help differently.
showHelp: aHelpText for: view: actual method which is supposed to display the help text.
Should be redefined in concrete classes, to put the help text
into some info label, or the windows title bar.
Here, the help text is ignored.
showingHelp: return true, if the activeHelp manager should invoke my #showHelp:for:
method, when the mouse pointer is moved over my widgets.
The default here is true, however, the #showHelp:for: methods are empty.
These should be redefined to put the help text into some info label,
or into the views title bar.
You may also redefine the showingHelp/showingHelp: methods, to
remember the flag setting.

hooks

aboutToOpen: whichTopView: the topView is about to be opened.
This is sent by whichTopView, right before its really open
(i.e. finally visible)
commonPostBuild: a common hook for postBuildWith: and postBuildAsSubcanvasWith:.
commonPostOpen: a common hook for postOpenWith: and postOpenAsSubcanvasWith:.
commonPreBuild: a common hook for preBuildWith: and preBuildAsSubcanvasWith:.
postApplicationProcessCreate: newProcess windowGroup: newGroup: this is sent whenever a new application is launched from this app,
which forks its own windowGroup process. Allows for process group management,
or process-global exception handlers to be installed.
Nothing done here - to be redefined in concrete applications
postBuildAsSubcanvasWith: aBuilder: this is sent after an interface is built from a spec as subcanvas.
Can be redefined in subclasses for additional setup after
the subcanvas view has been built, but not yet opened.
postBuildWith: aBuilder: this is sent after an interface is built from a spec.
Can be redefined in subclasses for additional setup after
the view has been built, but not yet opened.
postOpenAsSubcanvasWith: aBuilder: this is sent after the applications window is opened inside another application.
Can be redefined in subclasses for actions after opening the view.
postOpenWith: aBuilder: this is sent after the applications main window is opened.
Can be redefined in subclasses for actions after opening the view.
preBuildAsSubcanvasWith: aBuilder: this is sent before an interface is built from a spec as a subcanvas.
Can be redefined for apps which need to be informed about that.
preBuildWith: aBuilder: this is sent before an interface is built from a spec.
Can be redefined in subclasses.
mhmh - what should this do here ?
preOpenWith: aBuilder: this is sent before the applications main window is opened.
Can be redefined in subclasses for actions right before opening the view.

initialization

addTopViewsToCurrentProject: add all of my topViews to the current projects list of views.
This allows hiding views on a per-project basis.
Applications which do not want to be switched with projects
(such as the Launcher), may redefine this to a noop.
basicInitialize: initialize the application.
Since ST-80 applications seem commonly to redefine #initialize
without doing a super initialize, the real initialization is
done here ...
initialize: nothing done here;
but can be redefined in concrete applications
initializeDevice
initializeResources: initialize the applications resources (NLS support).
initializeScreenDevice
setDevice: aDevice: set the device (i.e. some Screen), where the application shall open its view(s).
The default device (if not set here) will be the current screen.

misc

information: aString: like Objects information, but translates the string via the
resourcePack, thus giving a translated string automatically
notify: aString: like Objects notify, but translates the string via the
resourcePack, thus giving a translated string automatically
openDocumentationFile: aFilename
restoreCursors: restore the original cursors in all of my views
showCursor: aCursor: set all of my views cursor to aCursor.
It can be restored with #restoreCursor.
warn: aString: like Objects warn, but translates the string via the
resourcePack, thus giving a translated string automatically
warn: aString translate: aBoolean: like Objects warn, but optionally translates the string via the
resourcePack, thus giving a translated string automatically
warn: aString with: arg: like Objects warn, but translates the string via the
resourcePack, thus giving a translated string automatically
warn: aString with: arg1 with: arg2: like Objects warn, but translates the string via the
resourcePack, thus giving a translated string automatically
warn: aString with: arg1 with: arg2 with: arg3: like Objects warn, but translates the string via the
resourcePack, thus giving a translated string automatically
warn: aString with: arg1 with: arg2 with: arg3 with: arg4: like Objects warn, but translates the string via the
resourcePack, thus giving a translated string automatically
warn: aString withArguments: argArray: like Objects warn, but translates the string via the
resourcePack, thus giving a translated string automatically.
Also translates \'s to newLine.
withCursor: aCursor do: aBlock: evaluate aBlock, showing aCursor in my topView and all of its subviews.
Return the value of aBlock.
withExecuteCursorDo: aBlock: evaluate aBlock, showing an executeCursor in my topView and all of its subviews.
Return the value of aBlock.
withReadCursorDo: aBlock: evaluate aBlock, showing a readCursor in my topView and all of its subviews.
Return the value of aBlock.
withWaitCursorDo: aBlock: evaluate aBlock, showing a waitCursor in my topView and all of its subviews.
Return the value of aBlock.
withWaitCursorVisibleDo: aBlock: evaluate aBlock, showing a waitCursor in my topView and all of its subviews.
Return the value of aBlock.
Guarantee, that the cursor is visible by the user for a minimal amount of time.

opening

open: open a standard interface
openAndWaitUntilVisible: open a standard interface, and wait until my window is visible
openAs: windowType: open a standard interface as slave, partner, dialog etc.
openAsSlave: open a standard interface as slave.
Notice: there is still a need to make the current window a master
(see code and comments in WindowBuilder >> openAt:withExtent:andType:)
openAt: aPoint: open a standard interface at some point
openDialog: open the window - assumes that the builder has already setup
the interface.
openDialogInterface: aSelector: open a dialog
openDialogInterface: aSelector withBindings: bindings: open a dialog, given a spec-selector
openDialogInterfaceSpec: aSpec withBindings: bindings: open a dialog, given a spec
openDialogSpec: aSpec withBindings: bindings: open a dialog
openInterface: open a standard interface.

Subclasses which do not have an interfaceSpec
should redefine this method and create & open their view(s) there.
(see Launcher as an example).
openInterface: aSymbol: open a specific interface.
The argument, aSymbol specifies which interface. The concrete
application subclass must provide a method with that name,
which must return an interfaceSpec. This is forwarded to
the builder to create the views.
Typically, applications only use one interface,
returned by the #windowSpec method.
openInterface: aSymbol as: windowType: open a specific interface.
The argument, aSymbol specifies which interface.
The concrete application subclass must provide a method with that name,
which must return an interfaceSpec. This is forwarded to the builder to create the views.
Typically, applications only use one interface, returned by the #windowSpec method.
The windowType can be any of #slave, #partner, #dialog, #popUp etc.
openInterface: aSymbol at: aLocation: open a specific interface.

The argument, aSymbol specifies which interface. The concrete
application subclass must provide a method with that name,
which must return an interfaceSpec. This is forwarded to
the builder to create the views.
Typically, applications only use one interface,
returned by the #windowSpec method.
openInterfaceAs: windowType: open a standard interface.
The windowType can be any of #slave, #partner, #dialog, #popUp etc.
Subclasses which do not have an interfaceSpec
should redefine this method and create & open their view(s) there.
(see Launcher as an example).
openInterfaceAt: aLocation: open a standard interface.
openInterfaceModal: open a standard interface as a modal dialog.

Subclasses which do not have an interfaceSpec
should redefine this method and create & open their view(s) there.
(see Launcher as an example).
openInterfaceModal: aSymbol: open a specific interface as a modal dialog.
The argument, aSymbol specifies which interface. The concrete
application subclass must provide a method with that name,
which must return an interfaceSpec. This is forwarded to
the builder to create the views.
Typically, applications only use one interface,
returned by the #windowSpec method.
openInterfaceModal: aSymbol at: location: open a specific interface modal at some screen location.
The argument, aSymbol specifies which interface. The concrete
application subclass must provide a method with that name,
which must return an interfaceSpec. This is forwarded to
the builder to create the views.
Typically, applications only use one interface,
returned by the #windowSpec method.
openModal: open a standard interface as a modal dialog
openOnDevice: aDevice: open a standard interface on some other device
openSpec: anInterfaceSpec: open a view as specified in anInterfaceSpec.
openSpec: anInterfaceSpec withBindings: bindings: open a view as specified in anInterfaceSpec.
openSpec: anInterfaceSpec withBindings: bindings modal: modal: open a view as specified in anInterfaceSpec.
openSpecModal: anInterfaceSpec: open an interface spec modal
openWindow: open the window - assumes that the builder has already setup
the interface.
openWindowAs: windowType: open the window - assumes that the builder has already setup the interface.
The windowType can be any of #slave, #partner, #dialog, #popUp etc.
openWindowAt: aLocation: open the window - assumes that the builder has already setup
the interface.
openWindowAtCenter: open the window centered on the screen
- assumes that the builder has already setup the interface.
openWindowModal: open the window - assumes that the builder has already setup
the interface.
openWindowModalAt: aLocation: open the window modal - assumes that the builder has already setup
the interface.
openWithExtent: extPoint: open a standard interface with given extent
opened: whichTopView: the topView has been opened.
This is sent by whichTopView, when its really open
(i.e. finally visible)

opening-webInterface

addToService
createWebBuilder: create a Web-UIBuilder if not already present
defaultPageSpecName
defineInterface: define a standard interface.

Subclasses which do not have an interfaceSpec
should redefine this method and create their page there.
defineInterface: aSpecSymbol: define an interface.
defineInterfaceFrom: aSpec: define an interface (setup a page), given a spec.
httpServerPort: on which port will a HTTP server be started
initializeAsWebServiceOnWebDevice: webDevice
initializeWebServiceDevice: no real device here; instead, we need a web service in which I register.
The device is a dummy one, to make the protocol transparent & compatible
pageSpecs
service
service: something
serviceLinkName
startAsWebService
startInPortalService: aPortalServiceOrSession
webBuilderClass: return the UIBuilder class for me.
This method can be redefined if (eventually) there are
spec readers for other UI languages (motif UIL ?)
webLink: if nil is returned, I will install my page(s) right under the serviceLink (i.e. /portal/nn).
Otherwise, they will be under (i.e. /portal/link/nn)
webLink: something

private

builderClass: return the UIBuilder class for me.
This method can be redefined if (eventually) there are
spec readers for other UI languages (motif UIL ?)
createBuilder: create a WindowBuilder if not already present

queries

defaultWindowSpecName
defaultWindowType: Applications come up non-modal, by default
graphicsDevice: return the device I want to open my views on.
The default (if not created with #onDevice:) is the currently
active screen.
interfaceSpecFor: aSelectorOrSpec: return an interface spec.
Here, the query is forwarded to my class.
Can be refefined in subclasses which want to provide per-instance specs.
isOpen: answer true if the application's window is open
isWebService
processName: return a name to be shown for me in the process monitor
resolveClassNamed: something inClass: aClass: return the class from something, a class, symbol, string or nil.
first we are looking in the namespace of the application, then in the
current namespace and finally in Smalltalk
resolveName: something: return the class from something, a class, symbol, string or nil.
first we are looking in the namespace of the application, then in the
current namespace and finally in Smalltalk
resolveName: something inClass: aClass: return the class from something, a class, symbol, string or nil.
first we are looking in the namespace of the application,
then in the current namespace and finally in Smalltalk
selfResponsibleFor: aKey: internal: return true, if I am to provide a value for some aspect.

** This is an obsolete interface - do not use it (it may vanish in future versions) **
topApplication: return the top-master application

startup & release

applicationWindowClass: return the class used for my (top-) windows
close: this is sent by my topView when about to be closed
by the program (not by the windowManager).
Notice, that we get a closeRequest message if closed by the windowManager,
which can be rejected by the app (or confirmed via a dialog)
Could be redefined in subclasses.
closeDownViews: close down the applications view(s)
closeRequest: this is sent by my topView when about to be closed by the windowManager.
Could be redefined in subclasses to suppress close or confirm.
closeRequestFor: aTopView: this is sent by any of my topViews when about to be closed by the
windowmanager. For backward compatibility with single-view applications,
this is forwarded here to a simple (non topView-specific) closeRequest,
effectively closing all of my views.
MultiView applications should redefine this method if closing of individual
views closing is to be caught and/or should not close all of them.
doAccept: this is invoked by the Return-Key (if returnIsOK) or
the ok-button (if any), IFF the application has been
opened modal (i.e. as a dialog).
doCancel: this is invoked by the Escape-Key (if escapeIsCancel) or
the cancel-button (if any), IFF the application has been
opened modal (i.e. as a dialog).
releaseAsSubCanvas: a subcanvas is closed or switching to a new application.
Can be redefined to perform a self release in this case.
restarted: sent by my topWindow, when restarted from an image.
Nothing done here, but can be redefined to perform any actions
required to reset the application after an image-restart.
(for example: check if application files are still around, restart
subprocesses etc.).
saveAndTerminateRequest: some windowManagers send this to shut down an application
and have it save its state for restart.
Can be redefined in subclasses
saveAndTerminateRequestFor: aTopView: some windowManagers send this to shut down an application
and have it save its state for restart.
Can be redefined in subclasses

translating

translateString: aString: translate aString to the current language.
We use the resorces as default.
Subclasses may redefine this to use another mechanism

window events

clientMessage: msgType format: msgFormat eventData: msgData: a client message - very X-Window specific and only useful for special applications.
Subclasses prepared to receive them should redefine this method
copyDataEvent: parameter eventData: msgData: a client message - very Win32 specific and only useful for special applications.
Subclasses prepared to receive them should redefine this method
dispatchEvent: event: dispatch a user-pushed event.
This allows for events for an appModel to be pushed into the event queue
the same way as events for a view are pushable.
dispatchEvent: evType arguments: evArgs withFocusOn: focusView delegate: doDelegate: dispatch a user-pushed event.
This allows for events for an appModel to be pushed into the event queue
the same way as events for a view are pushable.
dispatchEvent: ev type: evType arguments: evArgs withFocusOn: focusView delegate: doDelegate: dispatch a user-pushed event.
This allows for events for an appModel to be pushed into the event queue
the same way as events for a view are pushable.
dispatchEvent: event withFocusOn: focusViewOrNil: dispatch a user-pushed event.
This allows for events for an appModel to be pushed into the event queue
the same way as events for a view are pushable.
dispatchEvent: event withFocusOn: focusViewOrNil delegate: doDelegate: dispatch a user-pushed event.
This allows for events for an appModel to be pushed into the event queue
the same way as events for a view are pushable.
noticeOfWindowClose: aWindow: sent when a topView or applicationSubView has been closed.
Can be redefined in subclasses for cleanup.
noticeOfWindowOpen: aWindow: sent when a topView or applicationSubView has been opened.
Can be redefined in subclasses.
processApplicationCommand: command with: argument: a message from a secondary application instance (the exe has been started again).
Typically, the command is one like 'openPath:', as generated in StandaloneStartup.
processOpenPathCommand: argument: a message from a secondary application instance (the exe has been started again)
to open another window on document as found in the pathName argument.
Left blank (i.e. ignored) here, but can be redefined to open up another application
editor window if supported.
requestForWindowClose: the applicationWindow wants to know, if a close
is ok. Return false if not.
showActivity: someMessage: some activityNotification shalt be communicated to
the user. Forwarded from the topView and ignored here.
Can be redefined in concrete applications to show the
message either in some infoView (infoLabel as in Windows)
or in the title area (as done in the browsers)
windowEvent: anEvent from: anApplicationWindow: dummy: windowEvent forwarding is not yet implemented

ST/X 6.1.1; WebServer 1.620 at exept:8081; Thu, 17 May 2012 15:52:04 GMT