"

 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'

	 classVariableNames:'ActiveGroup ScheduledWindowGroups LeaveSignal'

	 poolDictionaries:''

	 category:'Interface-Support'

!

WindowGroup comment:'

COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

'!

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

"

!

version

"

"

!

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 input event queue. 

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

    which waits for and forwards them to a controller (*). 

    Therefore, multiple applications run in parallel.

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

    box, but execute 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 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 pipe for incoming text).

    On the other hand, multiple topviews can be associated in the same windowGroup;

    this 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)

	ActiveGroup             the currently active windowGroup

	ScheduledWindowGroups   -- not currently used --

    (*) 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, only buttons, toggles and subclasses do so.

    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'.

	"/ ScheduledWindowGroups := IdentitySet new.

    ].

    "WindowGroup initialize"

! !

!WindowGroup class methodsFor:'signal access'!

leaveSignal

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

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

    ^ LeaveSignal

! !

!WindowGroup class methodsFor:'instance creation'!

new

    "create and return a new WindowGroup object"

    ^ self basicNew initialize

! !

!WindowGroup class methodsFor:'accessing'!

activeGroup

    "return the currently active windowGroup"

    ^ ActiveGroup

!

scheduledWindowGroups

    "this is not yet implemented"

    ^ ScheduledWindowGroups

! !

!WindowGroup methodsFor:'accessing'!

sensor

    "return the windowGroups sensor"

    ^ mySensor

!

addView:aView

    "add aView to the windowGroup"

    views isNil ifTrue:[

	views := OrderedCollection new.

    ].

    views add:aView

!

addTopView:aView

    "add a topview to the group"

    topViews isNil ifTrue:[

	topViews := OrderedCollection new.

    ].

    topViews add:aView

!

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 (and terminate if so)

    "

    mySensor notNil ifTrue:[mySensor eventSemaphore signal]

!

views

    "return the views accociated to this windowGroup"

    ^ views

!

topViews

    "return the topviews accociated to this windowGroup"

    ^ topViews

!

process 

    "return the windowGroups process"

    ^ myProcess

!

isModal

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

    ^ isModal

!

previousGroup

    "return the windowgroup that started this group.

     (for modal groups only)"

    ^ previousGroup

!

mainGroup

    "return the main windowgroup (that is the top one,

     which is not modal)"

    |g|

    g := self.

    [g notNil and:[g isModal]] whileTrue:[

	g := g previousGroup

    ].

    ^ g

!

sensor:aSensor

    "set the windowGroups sensor"

    mySensor := aSensor

! !

!WindowGroup methodsFor:'enumerating'!

allViewsDo:aBlock

    "evaluate aBlock for all views & topviews in this group"

    topViews notNil ifTrue:[topViews do:aBlock].

    views notNil ifTrue:[views do:aBlock]

! 

allTopViewsExcept:aView do:aBlock

    "evaluate aBlock for all topviews except aView in this group"

    topViews notNil ifTrue:[

	topViews do:[:v |

	    v ~~ aView ifTrue:[aBlock value:v]

	]

    ].

! !

!WindowGroup methodsFor:'special'!

showCursor:aCursor

    "change the cursor to aCursor in all of my views"

    |c|

    c := aCursor.

    self allViewsDo:[:aView |  

	c := c on:(aView device).

	aView device setCursor:c id in:aView id.

    ].

!

restoreCursors

    "restore the original cursors in all of my views"

    |c|

    self allViewsDo:[:aView |  

	c := aView cursor on:(aView device).

	aView device setCursor:(c id) in:(aView id).

    ].

!

withCursor:aCursor do:aBlock

    "evaluate aBlock while showing aCursor in all

     my views (used to show wait-cursor while doing something)"

    |oldCursors|

    "

     get mapping of view->cursor for all of my subviews

    "

    oldCursors := IdentityDictionary new.

    self allViewsDo:[:aView |

	oldCursors at:aView put:(aView cursor).

	aView cursor:aCursor

    ].

    aBlock valueNowOrOnUnwindDo:[

	"

	 restore cursors

	"

	oldCursors keysAndValuesDo:[:view :cursor |

	    view cursor:cursor

	]

    ]

! !

!WindowGroup methodsFor:'event handling'!

processEvents

    "process events from either the damage- or user input queues.

     Abort is assumed to be handled elsewhere."

    |event ignore|

    self processExposeEvents.

    [mySensor hasEvents] whileTrue:[

	event := mySensor nextEvent.

	event notNil ifTrue:[

		"/

		"/ FocusStepping is done right here

		"/

		ignore := false.

		event isKeyPressEvent ifTrue:[

		    event key == #FocusNext ifTrue:[

			self focusNext.

			ignore := true

		    ].

		    event key == #FocusPrevious ifTrue:[

			self focusPrevious.

			ignore := true

		    ].

		].

		ignore ifFalse:[

		    "/

		    "/  button events turn off explicit focus, and revert

		    "/  to implicit focus control

		    "/

		    (focusView notNil

		    and:[event isButtonEvent]) ifTrue:[

			self focusView:nil

		    ].

		    "/

		    "/ let the event forward itself

		    "/

		    event sendEventWithFocusOn:focusView.

		]

	    ]

	].

    ]

!

processExposeEvents

    "process only expose events from the damage queue"

    |event view rect oldActive x y w h sensor|

    (sensor := mySensor) isNil ifTrue:[^ self].

    oldActive := ActiveGroup.

    [

	[sensor hasDamage] whileTrue:[

	    ActiveGroup := self.

	    event := sensor nextDamage.

	    event notNil ifTrue:[

		(views notNil or:[topViews notNil]) ifTrue:[

		    event isDamage ifTrue:[

			view := event view.

			"/

			"/ if the view is no longer shown (iconified or closed),

			"/ this is a leftover event and ignored.

			"/

			view shown ifTrue:[

			    rect := event rectangle.

			    x := rect left.

			    y := rect top.

			    w := rect width.

			    h := rect height.

			    view transformation notNil ifTrue:[

				view deviceExposeX:x y:y width:w height:h

			    ] ifFalse:[

				view exposeX:x y:y width:w height:h

			    ]

			]

		    ] ifFalse:[

			"

			 mhmh - could we possibly arrive here ?

			"

			event sendEvent.

		    ]

		]

	    ]

	]

    ] valueNowOrOnUnwindDo:[

	ActiveGroup := oldActive.

	oldActive := nil

    ]

!

eventLoop

    "loop executed by windowGroup process;

     wait-for and process events forever"

   self eventLoopWhile:[true]

!

eventLoopWhile:aBlock

    "wait-for and process events. 

     Stay in this loop while there are still any views to dispatch for,

     and aBlock evaluates to true."

    |oldActive|

    oldActive := ActiveGroup.

    [

"/     ScheduledWindowGroups add:self.

	"/

	"/ on leave, exit the event loop

	"/

	LeaveSignal handle:[:ex |

	    ex return

	] do:[

	    |p g mainGroup thisProcess|

	    isModal ifTrue:[

		mainGroup := self mainGroup.

	    ].

	    thisProcess := Processor activeProcess.

	    aBlock whileTrue:[ 

		ActiveGroup := self.

		(views isNil and:[topViews isNil]) ifTrue:[

		    myProcess notNil ifTrue:[

			p := myProcess.

			myProcess := nil.

			p terminate.

			"not reached - there is no life after death"

		    ].

		    "

		     this is the end of a modal loop

		     (not having a private process ...)

		    "

		    ^ self

		].

		"/

		"/ on abort, stay in the event loop

		"/