"

 COPYRIGHT (c) 1993 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.

"

Object subclass:#WindowGroup

	 instanceVariableNames:'views topViews myProcess mySensor isModal previousGroup focusView

		focusSequence preEventHook postEventHook'

	 classVariableNames:'LastActiveGroup LastActiveProcess LeaveSignal'

	 poolDictionaries:''

	 category:'Interface-Support'

!

!WindowGroup class methodsFor:'documentation'!

copyright

"

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

"

    In Smalltalk/X, the known (ST-80) concept of a controller has been

    extended to a WindowGroup which handles process related stuff, and

    the Controller, which handles events only and defines the user interaction.

    There is no polling in controllers (not even conceptionally).

    WindowGroups are responsible to wait for and forward events for a group of 

    windows. All views in a group share a single windowSensor which holdes the

    event queue (therefore views all share the same input event queue).

    Except for modal boxes, a separate process is created for each windowGroup 

    which waits for events and processes them, by sending corresponding

    event messages to the views controller or the view (*). 

    Therefore, multiple applications run in parallel.

    Modal boxes create an extra window group for the components of the modal

    box, but execute the event-processing loop in the original process - 

    therefore, the original windowgroup is blocked for the duration of the modal 

    interaction (**).

    Normally, one windowgroup is associated to each topview (StandardSystemView)

    and all of its subviews. However, this is not strictly required; 

    it is possible to create extra windowgroups for subviews, which will let them

    run in parallel 

	(for example, the FileBrowsers kill Button is created that 

	 way, to allow a kill of an executing unix command, while the browser 

	 itself reads the pipeStream for incoming text).

    On the other hand, multiple topviews can be placed into the same windowGroup;

    which allows for multiview applications, of which only one communicates with

    the user at a time.

    Although currently not implemented, it is planned for a future version,

    to also handle all topviews of a windowgroup as a unit with respect to

    iconification and deiconification: if any of a windowgroups topviews gets

    iconified, all others will be as well.

    WindowGroups also support a focus window: this is the one that gets the

    keyboard input - even if the cursor is located in another subview.

    (this is a brand new feature and not yet released for public use)

    Finally, windowgroups are the perfect place for things like defining a

    cursor for all associated views, flushing all input, waiting for expose

    events etc.

    You dont have to care for details in the normal case, a windowgroup is

    created for you automatically, when a view is opened.

    instance variables:

	views                   collection of views of this group

	topViews                collection of topviews of this group

	myProcess               the process executing the events

	mySensor                my input sensor

	isModal                 true if this is for a modal box

	previousGroup           if modal, the group that started this one

	focusView               the one that has the focus (or nil)

	focusSequence           defines the focus sequence

    clas variables:

	LeaveSignal             if raised, a modal box leaves (closes)

    (*) 

	due to historic reasons, many views have the controller functionality

	integrated, and handle events themself. The windowSensor takes care

	of this, by checking if a view has a controller, and, if so, forwarding 

	the events to it. Otherwise, events are sent directly to the view.

	In the future, all views will be rewritten to actually use a controller.

	Currently (being in the middle of this migration), only some views

	(buttons, toggles and subclasses) do so.

    (**)

	the modal-event loop peeks into the original groups damage queue

	in regular time intervals - therefore, view updating is still done in

	the blocked group.

    For more information, read 'introduction to view programming' in the

    doc/online directory.

"

! !

!WindowGroup class methodsFor:'initialization'!

initialize

    LeaveSignal isNil ifTrue:[

	LeaveSignal := (Signal new) mayProceed:true.

	LeaveSignal nameClass:self message:#leaveSignal.

	LeaveSignal notifierString:'unhandled leave signal'.

    ].

    "WindowGroup initialize"

! !

!WindowGroup class methodsFor:'instance creation'!

new

    "create and return a new WindowGroup object"

    ^ self basicNew initialize

! !

!WindowGroup class methodsFor:'Signal constants'!

leaveSignal

    "return the signal which is used to exit a modal loop.

     This private signal, is always cought while a modalbox is active.

     Raising it will exit the modal loop and return from the views #openModal

     method."

    ^ LeaveSignal

! !

!WindowGroup class methodsFor:'accessing'!

activeGroup

    "return the currently active windowGroup.

     The returned value may not be fully correct, in case the current process

     handles multiple windowGroups simulaniously. In this case, 

     the first group is returned (prefering a modal if there is one). 

     (maybe we should return a collection of windowGroups here).

     This method is required to simulate the historic ST-80 single display

     behavior for Cursor>>show / Cursor>>showWhile and some others (raising the

     activeGroups topView when modalBoxes appear) on multiple display screens. 

     These methods should change the cursor for the currently 

     active windowGroup ONLY, instead of globally affecting the display or

     all views

     (since, depending on the priority, other views could be unaffacted by this 

      and an overall cursor change does not make sense.)"

    |activeProcess groups wg|

    Processor isNil ifTrue:[^ nil]. "/ only during very early init phase

    activeProcess := Processor activeProcess.

    " caching the last value ..."

    activeProcess == LastActive ifTrue:[

	LastActiveGroup process == LastActive ifTrue:[

	    ^ LastActiveGroup

	]

    ].

    groups := self scheduledWindowGroups 

		select:[:wg | wg process == activeProcess].

    groups size == 1 ifTrue:[

	wg := groups anElement

    ] ifFalse:[

	wg := groups detect:[:wg | wg isModal] ifNone:nil.

	wg isNil ifTrue:[

	    wg := groups anElement

	]

    ].

    wg notNil ifTrue:[

	LastActiveProcess := activeProcess.

	LastActiveGroup := wg.

    ].

    ^ wg

    "

     WindowGroup activeGroup 

    "

    "Modified: 3.9.1995 / 14:49:53 / claus"

!

scheduledWindowGroups

    "return a collection of all windowGroups (possibly for different

     display devices) which are scheduled (i.e. which have a process 

     running, handling events)."

    |set screens|

    screens := Screen allScreens.

    screens isNil ifTrue:[^ #()].

    set := IdentitySet new.

    screens do:[:aDevice |

	aDevice allViewsDo:[:aView |

	    |wg|

	    (wg := aView windowGroup) notNil ifTrue:[

		wg process notNil ifTrue:[

		    set add:wg

		]

	    ].

	].

    ].

    ^ set asArray

    "

     WindowGroup scheduledWindowGroups   

    "

    "Modified: 1.9.1995 / 13:43:09 / claus"

!

setActiveGroup:aGroup

    "set the currently active windowGroup.

     Temporary; do not use this interface, it will vanish."

    LastActiveProcess := Processor activeProcess.

    LastActiveGroup := aGroup

! !

!WindowGroup methodsFor:'accessing'!

addTopView:aView

    "add a topview to the group"

    topViews isNil ifTrue:[

	topViews := OrderedCollection new.

    ].

    topViews add:aView

!

addView:aView

    "add aView to the windowGroup"

    views isNil ifTrue:[

	views := OrderedCollection new.

    ].

    views add:aView

!

isModal

    "return true, if I am in a modal mode"

    ^ isModal

!

mainGroup

    "return the main windowgroup 

     (that is the top one, which is not modal).

     There is one exception to this: the debugger (which is sort of modal)

     returns itself as mainGroup (not its debuggee)."

    |g prev|

    g := self.

    [g notNil and:[g isModal and:[(prev := g previousGroup) notNil]]] whileTrue:[

	g := prev

    ].

    ^ g

    "Modified: 3.9.1995 / 14:57:20 / claus"

!

postEventHook:anObject 

    "set the postEventHook - this one will get all events

     passed after being processed here (via #processEvent:)."

    postEventHook := anObject

!

preEventHook:anObject 

    "set the preEventHook - this one will get all events

     passed before being processed here (via #processEvent:).

     If this returns true, the event is supposed to be already

     processed and ignored here.

     Otherwise, it is processed as usual."

    preEventHook := anObject

!

previousGroup

    "return the windowgroup that started this group.

     (for modal groups only)"

    ^ previousGroup

!

process 

    "return the windowGroups process"

    ^ myProcess

!

removeView:aView

    "remove aView from the windowGroup;

     if this was the last view in this group, 

     also shut down the corresponding process 

     (actually, only wake it up here - it will terminate itself 

      when finding out that all views are gone)"

    views notNil ifTrue:[

	views remove:aView ifAbsent:[].

	views isEmpty ifTrue:[

	    views := nil

	]

    ].

    topViews notNil ifTrue:[

	topViews remove:aView ifAbsent:[].

	topViews isEmpty ifTrue:[

	    topViews := nil

	]

    ].

    "

     wakeup my process to look if last view has been

     removed (modalBoxes terminate their modalLoop if so)

    "

    mySensor notNil ifTrue:[

	(sema := mySensor eventSemaphore) notNil ifTrue:[

	    sema signal

	]

    ]

!

sensor

    "return the windowGroups sensor"

    ^ mySensor

!

sensor:aSensor

    "set the windowGroups sensor"

    mySensor := aSensor

!

topViews

    "return the topviews accociated to this windowGroup"

    ^ topViews

!

views

    "return the views accociated to this windowGroup"

    ^ views

! !

!WindowGroup methodsFor:'activation / deactivation'!

closeDownViews

    "destroy all views associated to this window group"

    topViews notNil ifTrue:[

	topViews do:[:aTopView | aTopView destroy]

    ].

    views := nil.

    topViews := nil.

    mySensor := nil.

!

realizeTopViews:isRestart

    "realize all topViews associated to this windowGroup.

     If this is a restart, tell topViews about it."

    topViews notNil ifTrue:[

	topViews do:[:aView |

	    aView realize.

	    isRestart ifTrue:[

		aView restarted

	    ]

	].

    ].

!

restart

    "restart after a snapin."

    topViews notNil ifTrue:[

	"

	 need a new semaphore, since obsolete processes 

	 (from our previous live) may still sit on the current semaphore

	"

	mySensor eventSemaphore:Semaphore new.

	isModal ifFalse:[

	    self startup:true 

	]

    ]

!

shutdown

    "shutdow the window group; close all views and

     terminate process"

    |p|

    self closeDownViews.

    myProcess notNil ifTrue:[

	p := myProcess.

	myProcess := nil.

	p terminate.

    ]

!

startup:isRestart

    "startup the window-group;

     this creates a new window group process, which

     does the event processing."

    |top nm dev devNm|

    previousGroup := nil.

    myProcess isNil ifTrue:[

	isModal := false.

	myProcess := [

	    self realizeTopViews:isRestart.

	    self eventLoopWhile:[true] onLeave:[]

	] forkAt:Processor userSchedulingPriority.

	(topViews notNil and:[topViews isEmpty not]) ifTrue:[

	    "

	     give the handler process a user friendly name

	    "

	    top := topViews first.

	    nm := top processName.

	    (dev := top device) notNil ifTrue:[

		devNm := dev displayName.

		(devNm notNil and:[devNm ~= Display displayName]) ifTrue:[

		    nm := nm , ' (' , devNm , ')'

		]

	    ]

	] ifFalse:[

	    nm := 'window handler'.

	].

	myProcess name:nm.

	"when the process dies, we have to close-down

	 the views as well

	"

	myProcess exitAction:[self closeDownViews]

    ]

!

startupModal:checkBlock

    "startup the window-group in a modal loop (i.e. under the

     currently running process);

     checkBlock is evaluated and loop is left, when false is

     returned."

    "set previousGroup to the main (non-modal) group"

    previousGroup := WindowGroup activeGroup.

    isModal := true.

    self realizeTopViews:false.

    self 

	eventLoopWhile:checkBlock 

	onLeave:[

	    "

	     cleanup, in case of a terminate