Opentalk-Tools-Monitor.pst

 
      1
    
 <?xml version="1.0"?>

<st-source>
<!-- 
Name: Opentalk-Tools-Monitor
Notice: Copyright © 2008 Cincom Systems, Inc.  All Rights Reserved.
Comment: Opentalk-Tools-Monitor defines a general purpose broker/adaptor event monitor.  It supports registration for events and event inspection.  It may also be used to monitor events generated during Opentalk SUnit test runs.
Copyright: Copyright © 1999-2002 Cincom Systems, Inc.
All Rights Reserved
DbIdentifier: bear73
DbTrace: 88204
DevelopmentPrerequisites: #(#(#package 'Opentalk-Tools-Basic' ''))
PackageName: Opentalk-Tools-Monitor
Parcel: #('Opentalk-Tools-Monitor')
ParcelName: Opentalk-Tools-Monitor
PrerequisiteParcels: #(#('Opentalk-Tools-Basic' ''))
PrintStringCache: (751 1,mkobetic)
Version: 7.6
Date: 1:02:04 pm February 1, 2008
 -->
<time-stamp>From VisualWorks®, 7.6 of February 1, 2008 on February 1, 2008 at 1:02:04 pm</time-stamp>


<do-it>(Dialog confirm: 'You are filing-in a Parcel source file!\\While this is possible it will not have\the same effect as loading the parcel.\None of the Parcel''s prerequisites will\be loaded and none of its load actions\will be performed.\\Are you sure you want to file-in?' withCRs) ifFalse: [self error: 'Parcel file-in abandoned.  Choose terminate or close.']</do-it>

<class>
<name>EventList</name>
<environment>Opentalk</environment>
<super>Protocols.EventCollector</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>filter </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Monitor</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</class>

<class>
<name>EventSubscriptionDisplayFrame</name>
<environment>Opentalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>subject path event </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Monitor</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</class>

<class>
<name>OpentalkMonitor</name>
<environment>Opentalk</environment>
<super>UI.ApplicationModel</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>componentListSubcanvas eventSubscriptionSubcanvas eventListSubcanvas </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Monitor</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</class>

<class>
<name>EventDisplayFrame</name>
<environment>Opentalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>time selector arguments component list </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Monitor</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</class>

<class>
<name>EventListSubcanvas</name>
<environment>Opentalk</environment>
<super>Opentalk.FilterableListSubcanvas</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>eventCollector listView </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Monitor</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</class>

<comment>
<class-id>Opentalk.EventListSubcanvas</class-id>
<body>Instance Variables:
	eventCollector	&lt;EventList&gt;	the list of received events
	listView	&lt;ListView&gt;	handle on the event list view

</body>
</comment>

<class>
<name>EventSubscriptionSubcanvas</name>
<environment>Opentalk</environment>
<super>UI.ApplicationModel</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>eventSubscriptionSIL selectionHolder componentHolder eventCollectorHolder subscriptionCache currentSubscription </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Monitor</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</class>

<shared-variable>
<name>SubscriptionsDictionary</name>
<environment>Opentalk.OpentalkMonitor</environment>
<private>false</private>
<constant>false</constant>
<category>subscriptions</category>
<attributes>
<package>Opentalk-Tools-Monitor</package>
</attributes>
</shared-variable>

<methods>
<class-id>Opentalk.EventList</class-id> <category>initialize/release</category>

<body package="Opentalk-Tools-Monitor" selector="initialize:">initialize: eventsSize

	events := List new: eventsSize</body>
</methods>

<methods>
<class-id>Opentalk.EventList</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="filter">filter
	^filter</body>

<body package="Opentalk-Tools-Monitor" selector="filter:">filter: anObject
	filter := anObject</body>
</methods>

<methods>
<class-id>Opentalk.EventList</class-id> <category>services</category>

<body package="Opentalk-Tools-Monitor" selector="log:from:">log: aMessage from: aComponent

	self process: (
		EventDisplayFrame
			time: Time millisecondClockValue
			selector: aMessage selector
			arguments: aMessage arguments
			from: aComponent
			for: self )</body>
</methods>

<methods>
<class-id>Opentalk.EventList</class-id> <category>private</category>

<body package="Opentalk-Tools-Monitor" selector="doesNotUnderstand:">doesNotUnderstand: aMessage

	| component context |
	context := thisContext sender sender.
	[ context isNil or: [ (component := context receiver) isKindOf: GenericProtocol ] ]
		whileFalse: [ context := context sender ].
	context isNil
		ifTrue: [ self process: aMessage ]
		ifFalse: [ (filter isNil or: [ filter shouldAccept: aMessage from: component ])
				ifTrue: [ self process: (
						EventDisplayFrame
							time: Time millisecondClockValue
							selector: aMessage selector
							arguments: aMessage arguments
							from: component
							for: self) ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="privateProcess:">privateProcess: anEvent

	events add: (anEvent asEventDisplayFrameFor: self)</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionDisplayFrame</class-id> <category>printing</category>

<body package="Opentalk-Tools-Monitor" selector="displayString">displayString

	| str |

	str := WriteStream on: ( String new: 32 ).
	path do: [ :sel | str 
					nextPutAll: sel asString;
					nextPut: Character space ].
	str nextPutAll: event asString.
	^str contents</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionDisplayFrame</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="event">event

	^event</body>

<body package="Opentalk-Tools-Monitor" selector="event:">event: aSymbol

	event := aSymbol</body>

<body package="Opentalk-Tools-Monitor" selector="path">path

	^path</body>

<body package="Opentalk-Tools-Monitor" selector="path:">path: anOrderedCollection

	path := anOrderedCollection</body>

<body package="Opentalk-Tools-Monitor" selector="subject">subject

	^subject</body>

<body package="Opentalk-Tools-Monitor" selector="subject:">subject: anObject

	subject := anObject</body>

<body package="Opentalk-Tools-Monitor" selector="target">target

	^path inject: subject into: [ :x :y | x perform: y ]</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionDisplayFrame</class-id> <category>initialize-release</category>

<body package="Opentalk-Tools-Monitor" selector="initialize">initialize

	subject := nil.
	path := OrderedCollection new: 2.
	event := nil</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionDisplayFrame class</class-id> <category>instance creation</category>

<body package="Opentalk-Tools-Monitor" selector="new">new

	^super new initialize</body>

<body package="Opentalk-Tools-Monitor" selector="subject:event:">subject: anObject event: aSymbol

	^( self new )
		subject: anObject;
		event: aSymbol;
		yourself</body>

<body package="Opentalk-Tools-Monitor" selector="subject:path:event:">subject: anObject path: anArray event: aSymbol

	^( self new )
		subject: anObject;
		path: anArray;
		event: aSymbol;
		yourself</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionDisplayFrame class</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="sortBlock">sortBlock

	^[:x :y | ( x path size &lt; y path size )
				or: [ x displayString &lt;= y displayString ] ]</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="componentListSubcanvas">componentListSubcanvas

	^componentListSubcanvas</body>

<body package="Opentalk-Tools-Monitor" selector="eventListSubcanvas">eventListSubcanvas

	^eventListSubcanvas</body>

<body package="Opentalk-Tools-Monitor" selector="eventSubscriptionSubcanvas">eventSubscriptionSubcanvas

	^eventSubscriptionSubcanvas</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor</class-id> <category>initialize-release</category>

<body package="Opentalk-Tools-Monitor" selector="initialize">initialize

	componentListSubcanvas := ComponentListSubcanvas new.
	eventListSubcanvas := EventListSubcanvas new.
	eventSubscriptionSubcanvas := EventSubscriptionSubcanvas new.
	eventSubscriptionSubcanvas componentHolder: componentListSubcanvas selectionHolder.
	componentListSubcanvas selectionHolder onChangeSend: #changedComponent to: self.
	eventListSubcanvas selectionIndexHolder onChangeSend: #changedEvents to: self.
	eventSubscriptionSubcanvas eventCollectorHolder value: eventListSubcanvas eventCollector.
	self filterEventsFromUnregisteredComponents: true.</body>

<body package="Opentalk-Tools-Monitor" selector="noticeOfWindowClose:">noticeOfWindowClose: aWindow

	#{Opentalk.Log} ifDefinedDo: [ :log |
		log == self eventListSubcanvas eventCollector
			ifTrue: [ #{Opentalk.Log} value: nil ] ].
	self release.
	^super noticeOfWindowClose: aWindow</body>

<body package="Opentalk-Tools-Monitor" selector="release">release

	componentListSubcanvas selectionHolder retractInterestsFor: self.
	eventListSubcanvas selectionIndexHolder retractInterestsFor: self.
	componentListSubcanvas release.
	eventSubscriptionSubcanvas release.
	eventListSubcanvas release.
	^super release</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor</class-id> <category>actions</category>

<body package="Opentalk-Tools-Monitor" selector="filterEventsFromUnregisteredComponents:">filterEventsFromUnregisteredComponents: aBoolean

	eventListSubcanvas eventFilter: (
		aBoolean
			ifTrue: [ eventSubscriptionSubcanvas ]
			ifFalse: [ nil ])</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor</class-id> <category>menu item actions</category>

<body package="Opentalk-Tools-Monitor" selector="clearAllLogItems">clearAllLogItems

	eventListSubcanvas clearAllLogItems.
	self changedEvents</body>

<body package="Opentalk-Tools-Monitor" selector="decrementComponentPort">decrementComponentPort

	componentListSubcanvas decrementPort</body>

<body package="Opentalk-Tools-Monitor" selector="incrementComponentPort">incrementComponentPort

	componentListSubcanvas incrementPort</body>

<body package="Opentalk-Tools-Monitor" selector="inspectComponent">inspectComponent

	componentListSubcanvas inspectComponent</body>

<body package="Opentalk-Tools-Monitor" selector="inspectLogItem">inspectLogItem

	eventListSubcanvas inspectLogItem</body>

<body package="Opentalk-Tools-Monitor" selector="refreshMonitor">refreshMonitor

	builder window refresh</body>

<body package="Opentalk-Tools-Monitor" selector="removeComponent">removeComponent

	componentListSubcanvas removeComponent</body>

<body package="Opentalk-Tools-Monitor" selector="selectAllSubscriptions">selectAllSubscriptions

	eventSubscriptionSubcanvas selectAllSubscriptions</body>

<body package="Opentalk-Tools-Monitor" selector="startComponent">startComponent

	componentListSubcanvas startComponent</body>

<body package="Opentalk-Tools-Monitor" selector="stopComponent">stopComponent

	componentListSubcanvas stopComponent</body>

<body package="Opentalk-Tools-Monitor" selector="unselectAllSubscriptions">unselectAllSubscriptions

	eventSubscriptionSubcanvas unselectAllSubscriptions</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor</class-id> <category>update</category>

<body package="Opentalk-Tools-Monitor" selector="changedComponent">changedComponent

	self resetMenuBar</body>

<body package="Opentalk-Tools-Monitor" selector="changedEvents">changedEvents

	self resetMenuBar</body>

<body package="Opentalk-Tools-Monitor" selector="resetMenuBar">resetMenuBar

	| bool mb |

	bool := componentListSubcanvas selectionHolder value ~~ nil.
	mb := self builder menuAt: #menuBar.
	( mb atNameKey: #startComponent ) enabled: bool.
	( mb atNameKey: #stopComponent ) enabled: bool.
	( mb atNameKey: #incrementComponentPort ) enabled: bool.
	( mb atNameKey: #decrementComponentPort ) enabled: bool.
	( mb atNameKey: #inspectComponent  ) enabled: bool.
	( mb atNameKey: #removeComponent ) enabled: bool.
	( mb atNameKey: #selectAllSubscriptions ) enabled: bool.
	( mb atNameKey: #unselectAllSubscriptions ) enabled: bool.

	bool := ( eventListSubcanvas eventCollector events size ) ~~ 0.
	( mb atNameKey: #clearAllLogItems ) enabled: bool.

	bool := ( eventListSubcanvas selectionInList selection ) ~~ nil.
	( mb atNameKey: #inspectLogItem ) enabled: bool.</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor</class-id> <category>interface opening</category>

<body package="Opentalk-Tools-Monitor" selector="postOpenWith:">postOpenWith: aBuilder

	self resetMenuBar</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor class</class-id> <category>class initialization</category>

<body package="Opentalk-Tools-Monitor" selector="initialize">initialize

	"((( OpentalkEventMonitoringTool initialize )))"

	SubscriptionsDictionary := IdentityDictionary new</body>
</methods>

<methods>
<class-id>Opentalk.EventDisplayFrame</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="arguments">arguments

	^arguments</body>

<body package="Opentalk-Tools-Monitor" selector="arguments:">arguments: anArray

	arguments := anArray</body>

<body package="Opentalk-Tools-Monitor" selector="component">component
	^component</body>

<body package="Opentalk-Tools-Monitor" selector="component:">component: anObject
	component := anObject</body>

<body package="Opentalk-Tools-Monitor" selector="list">list
	^list</body>

<body package="Opentalk-Tools-Monitor" selector="list:">list: anObject
	list := anObject</body>

<body package="Opentalk-Tools-Monitor" selector="selector">selector

	^selector</body>

<body package="Opentalk-Tools-Monitor" selector="selector:">selector: aSymbol

	selector := aSymbol</body>

<body package="Opentalk-Tools-Monitor" selector="time">time

	^time</body>

<body package="Opentalk-Tools-Monitor" selector="time:">time: anInteger

	time := anInteger</body>
</methods>

<methods>
<class-id>Opentalk.EventDisplayFrame</class-id> <category>filter aspects</category>

<body package="Opentalk-Tools-Monitor" selector="classname">classname

	^self component classname</body>

<body package="Opentalk-Tools-Monitor" selector="event">event

	^self selector</body>

<body package="Opentalk-Tools-Monitor" selector="hostAddress">hostAddress

	^self component accessPoint hostAddress</body>

<body package="Opentalk-Tools-Monitor" selector="port">port

	^self component port</body>

<body package="Opentalk-Tools-Monitor" selector="protocolTag">protocolTag

	^self component protocolTag</body>
</methods>

<methods>
<class-id>Opentalk.EventDisplayFrame</class-id> <category>converting</category>

<body package="Opentalk-Tools-Monitor" selector="asEventDisplayFrameFor:">asEventDisplayFrameFor: anEventList

	^self</body>
</methods>

<methods>
<class-id>Opentalk.EventDisplayFrame</class-id> <category>printing</category>

<body package="Opentalk-Tools-Monitor" selector="displayString">displayString

	| str tm |

	str := TextStream on: ( String new: 64 ).
	tm := (Time aTime: time // 1000) last.
	tm hours printOn: str paddedWith: $0 to: 2 base: 10.
	str nextPut: $:.
	tm minutes printOn: str paddedWith: $0 to: 2 base: 10.
	str nextPut: $:.
	tm seconds printOn: str paddedWith: $0 to: 2 base: 10.
	str	nextPut: $..
	time \\ 1000 printOn: str paddedWith: $0 to: 3 base: 10.
	str	space;
		print: component;
		space.
	list printEvent: self on: str.
	^str contents</body>
</methods>

<methods>
<class-id>Opentalk.EventDisplayFrame class</class-id> <category>instance creation</category>

<body package="Opentalk-Tools-Monitor" selector="time:selector:arguments:for:">time: anInteger selector: aSymbol arguments: anArray for: anEventList

	^( self new )
		time: anInteger;
		selector: aSymbol;
		arguments: anArray;
		list: anEventList
		yourself</body>

<body package="Opentalk-Tools-Monitor" selector="time:selector:arguments:from:for:">time: anInteger selector: aSymbol arguments: anArray from: aComponent for: anEventList

	^( self new )
		time: anInteger;
		selector: aSymbol;
		arguments: anArray;
		component: aComponent;
		list: anEventList
		yourself</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas</class-id> <category>aspects</category>

<body package="Opentalk-Tools-Monitor" selector="classnameFilterAdaptor">classnameFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 1 ]
		putBlock: [:m :v | m switchFilter:1 perform: #classname ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 1 ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="componentFilterAdaptor">componentFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 5 ]
		putBlock: [:m :v | m switchFilter: 5 perform: #component ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 5 ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="eventFilterAdaptor">eventFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 7 ]
		putBlock: [:m :v | m switchFilter: 7 perform: #event ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 7 ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="hostAddressFilterAdaptor">hostAddressFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 2 ]
		putBlock: [:m :v | m switchFilter: 2 perform: #hostAddress ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 2 ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="portFilterAdaptor">portFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 3 ]
		putBlock: [:m :v | m switchFilter: 3 perform: #port ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 3 ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="protocolTagFilterAdaptor">protocolTagFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 4 ]
		putBlock: [:m :v | m switchFilter: 4 perform: #protocolTag ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 4 ] ]</body>

<body package="Opentalk-Tools-Monitor" selector="subcomponentFilterAdaptor">subcomponentFilterAdaptor

	^(PluggableAdaptor on: self)
		getBlock: [:m | m hasFilter: 6 ]
		putBlock: [:m :v | m switchFilter: 6 perform: #subcomponent ]
		updateBlock: [:m :a :p | a == #filter and: [ p = 6 ] ]</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="eventCollector">eventCollector

	^eventCollector</body>

<body package="Opentalk-Tools-Monitor" selector="eventFilter">eventFilter

	^eventCollector filter</body>

<body package="Opentalk-Tools-Monitor" selector="eventFilter:">eventFilter: anEventSubscriptionSubcanvas

	eventCollector filter: anEventSubscriptionSubcanvas</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas</class-id> <category>initialize-release</category>

<body package="Opentalk-Tools-Monitor" selector="initialize">initialize

	eventCollector := EventList new.
	unfilteredList := eventCollector events.
	unfilteredList addDependent: self.
	super initialize</body>

<body package="Opentalk-Tools-Monitor" selector="initializeUnfilteredList">initializeUnfilteredList</body>

<body package="Opentalk-Tools-Monitor" selector="release">release

	unfilteredList removeDependent: self.
	super release</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas</class-id> <category>update</category>

<body package="Opentalk-Tools-Monitor" selector="changedEvents">changedEvents

	self updateList.
	listView scrollTo: (0 @ listView scrollableExtent y) negated</body>

<body package="Opentalk-Tools-Monitor" selector="changedSelection">changedSelection

	self updateDisplay</body>

<body package="Opentalk-Tools-Monitor" selector="update:">update: aSymbol 
	"... catches updates from the EventList."

	( aSymbol == #insert: ) 
		ifTrue: [ self changedEvents ].
	super update: aSymbol</body>

<body package="Opentalk-Tools-Monitor" selector="updateDisplay">updateDisplay

	| bool |

	bool := selectionHolder value notNil.

	( builder componentAt: #classnameCheckBox ) isEnabled: bool.
	( builder componentAt: #eventCheckBox ) isEnabled: bool.
	( builder componentAt: #componentCheckBox ) isEnabled: bool.
	( builder componentAt: #protocolTagCheckBox ) isEnabled: bool.
	( builder componentAt: #portCheckBox ) isEnabled: bool.
	( builder componentAt: #hostAddressCheckBox ) isEnabled: bool.</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas</class-id> <category>actions</category>

<body package="Opentalk-Tools-Monitor" selector="clearAllLogItems">clearAllLogItems

	Cursor execute
		showWhile: [
			filter := [:change | true].
			1 to: filterList size do: [ :i |
				filterList at: i put: nil.
				 self changed: #filter with: i ].
			unfilteredList removeAll: filteredList.
			filteredList := unfilteredList copy.
			selectionInList list: filteredList.
			self updateSelection: 0 ]</body>

<body package="Opentalk-Tools-Monitor" selector="inspectLogItem">inspectLogItem

	selectionInList selection inspect</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas</class-id> <category>private</category>

<body package="Opentalk-Tools-Monitor" selector="filterTemplates">filterTemplates

		^#(	#( filterByClassname filterByHostAddress filterByPort filterByProtocolTag filterByComponent filterByEvent )
		#( classname hostAddress port protocolTag component event ) )</body>

<body package="Opentalk-Tools-Monitor" selector="postBuildWith:">postBuildWith: aBuilder

	listView := (aBuilder componentAt: #selectionInList) widget</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas</class-id> <category>accessing</category>

<body package="Opentalk-Tools-Monitor" selector="componentHolder">componentHolder

	^componentHolder</body>

<body package="Opentalk-Tools-Monitor" selector="componentHolder:">componentHolder: aValueModel

	( componentHolder notNil )
		ifTrue:	[ componentHolder retractInterestsFor: self ].
	componentHolder := aValueModel.
	componentHolder onChangeSend: #changedComponent to: self</body>

<body package="Opentalk-Tools-Monitor" selector="eventCollectorHolder">eventCollectorHolder

	^eventCollectorHolder</body>

<body package="Opentalk-Tools-Monitor" selector="selectionHolder">selectionHolder

	^selectionHolder</body>

<body package="Opentalk-Tools-Monitor" selector="shouldAccept:from:">shouldAccept: aMessage from: component

	self componentHolder value ifNotNil: [ :selectedComponent |
		(component protocolTag = selectedComponent protocolTag)
			ifTrue: [^eventSubscriptionSIL selections anySatisfy: [ :frame |
					frame event = aMessage selector ] ] ].
	subscriptionCache associationsDo: [ :ass |
		(ass key protocolTag = component protocolTag) ifTrue: [
			^ass value value anySatisfy: [ :frame | frame event = aMessage selector ] ] ].
	^true</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas</class-id> <category>aspects</category>

<body package="Opentalk-Tools-Monitor" selector="eventSubscriptionSIL">eventSubscriptionSIL

	^eventSubscriptionSIL</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas</class-id> <category>initialize-release</category>

<body package="Opentalk-Tools-Monitor" selector="initialize">initialize

	self componentHolder: ValueHolder new.
	eventCollectorHolder := ValueHolder new.
	eventSubscriptionSIL := ( MultiSelectionInList new ).
	selectionHolder := eventSubscriptionSIL selectionHolder.
	selectionHolder onChangeSend: #changedSelectedEvents to: self.
	subscriptionCache := IdentityDictionary new.</body>

<body package="Opentalk-Tools-Monitor" selector="noticeOfWindowClose:">noticeOfWindowClose: aWindow

	self release.
	^super noticeOfWindowClose: aWindow</body>

<body package="Opentalk-Tools-Monitor" selector="release">release

	| targets collector |
	targets := subscriptionCache inject: Set new into: [ :set :ass |
				ass key inject: set into: [ :tset :ev |
					tset add: ev target; yourself ].
				set ].
	collector := eventCollectorHolder value.
	targets do: [ :t | t removeAllActionsWithReceiver: collector ].
	selectionHolder retractInterestsFor: self.
	componentHolder retractInterestsFor: self.
	^super release</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas</class-id> <category>actions</category>

<body package="Opentalk-Tools-Monitor" selector="selectAllSubscriptions">selectAllSubscriptions

	self eventSubscriptionSIL selectAll</body>

<body package="Opentalk-Tools-Monitor" selector="unselectAllSubscriptions">unselectAllSubscriptions

	self eventSubscriptionSIL clearAll</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas</class-id> <category>update</category>

<body package="Opentalk-Tools-Monitor" selector="changedComponent">changedComponent

	| sel |
	currentSubscription ifNotNil: [ :ass |
		ass
			key: eventSubscriptionSIL list;
			value: eventSubscriptionSIL selections ].
	sel := self componentHolder value.
	currentSubscription := sel isNil
		ifTrue: [ eventSubscriptionSIL list: List new. nil ]
		ifFalse: [ | ass |
			ass := subscriptionCache
					at: sel
					ifAbsentPut: [ sel allOwnAndComponentEventsFramed asList -&gt; #() ].
			eventSubscriptionSIL setList: ass key selecting: ass value.
			ass ]</body>

<body package="Opentalk-Tools-Monitor" selector="changedSelectedEvents">changedSelectedEvents

	| targets collector |

	targets := ( eventSubscriptionSIL list collect: [ :x | x target ] ) asSet.
	collector := eventCollectorHolder value.
	targets do: [ :t | t removeAllActionsWithReceiver: collector ].
	eventSubscriptionSIL selections
		do: [ :f | f target installMonitoringActionForEvent: f event and: collector ].
	"This is to update the count of handled events in the component subcanvas.
	It took some debugging of the DataSetView to figure this one out"
	self componentHolder value changed: #numberOfHandledEvents with: #reset</body>
</methods>

<methods>
<class-id>Opentalk.BasicRequestBroker class</class-id> <category>opentalk tool support</category>

<body package="Opentalk-Tools-Monitor" selector="eventTriggeringComponentSelectors">eventTriggeringComponentSelectors

	^#( #objectAdaptor )</body>
</methods>

<methods>
<class-id>Core.MessageSend</class-id> <category>opentalk</category>

<body package="Opentalk-Tools-Monitor" selector="asEventDisplayFrameFor:">asEventDisplayFrameFor: anEventList

	^Opentalk.EventDisplayFrame
		time: Time millisecondClockValue
		selector: selector
		arguments: args
		from: receiver
		for: anEventList</body>
</methods>

<methods>
<class-id>Opentalk.GenericProtocol class</class-id> <category>opentalk tool support</category>

<body package="Opentalk-Tools-Monitor" selector="eventTriggeringComponentSelectors">eventTriggeringComponentSelectors

	^#()</body>
</methods>

<methods>
<class-id>Opentalk.GenericProtocol</class-id> <category>opentalk tool support</category>

<body package="Opentalk-Tools-Monitor" selector="allComponentEvents">allComponentEvents

	^self class eventTriggeringComponentSelectors 
		inject:	( OrderedCollection new: 8 ) 
		into:	[ :x :y |	| sc |
						sc := self perform: y.
						x 
							addAll: ( sc class allEvents );
						 	addAll: ( sc allComponentEvents )
				]</body>

<body package="Opentalk-Tools-Monitor" selector="allComponentEventsFramed">allComponentEventsFramed

	^self allEventsFramedWithPath: ( OrderedCollection new: 2 )</body>

<body package="Opentalk-Tools-Monitor" selector="allEventsFramedWithPath:">allEventsFramedWithPath: anOrderedCollection

	| sc target |

	sc := SortedCollection sortBlock: EventSubscriptionDisplayFrame sortBlock.
	target := anOrderedCollection inject: self into: [ :x :y | x perform: y ].
	target class eventTriggeringComponentSelectors do:
		[ :sel |	| obj np scevs |
				obj := target perform: sel.
				np := anOrderedCollection copy.
				np add: sel.
				scevs := obj class allEvents.
				scevs do:	[ :ev |	sc add: ( EventSubscriptionDisplayFrame
												subject: target
												path: np
												event: ev )
							].
				sc addAll: ( self allEventsFramedWithPath: np ). 								
		].
	^sc</body>

<body package="Opentalk-Tools-Monitor" selector="allOwnAndComponentEvents">allOwnAndComponentEvents

	^self allOwnEvents addAll: self allComponentEvents</body>

<body package="Opentalk-Tools-Monitor" selector="allOwnAndComponentEventsFramed">allOwnAndComponentEventsFramed

	| sc |

	sc := self allOwnEventsFramed.
	sc addAll: self allComponentEventsFramed.
	^sc</body>

<body package="Opentalk-Tools-Monitor" selector="allOwnEvents">allOwnEvents

	^self class allEvents asOrderedCollection</body>

<body package="Opentalk-Tools-Monitor" selector="allOwnEventsFramed">allOwnEventsFramed

	^SortedCollection
		withAll: ( self allOwnEvents collect: [ :e | EventSubscriptionDisplayFrame subject: self event: e ] )
		sortBlock: EventSubscriptionDisplayFrame sortBlock</body>

<body package="Opentalk-Tools-Monitor" selector="installMonitoringActionForEvent:and:">installMonitoringActionForEvent: anEventSymbol and: anEventCollector

	self
		when: anEventSymbol
		evaluate: (
			LinkMessage
				receiver: anEventCollector
				selector: #log:from:
				arguments: (
					Array
						with: (ArgumentTransformer withBlock: [ :args |
								Message selector: anEventSymbol arguments: args ])
						with: self ) )</body>
</methods>

<methods>
<class-id>Core.Message</class-id> <category>opentalk</category>

<body package="Opentalk-Tools-Monitor" selector="asEventDisplayFrameFor:">asEventDisplayFrameFor: anEventList

	^Opentalk.EventDisplayFrame
		time: Time millisecondClockValue
		selector: selector
		arguments: args
		for: anEventList</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor class</class-id> <category>interface specs</category>

<body package="Opentalk-Tools-Monitor" selector="windowSpec">windowSpec
	"Tools.UIPainter new openOnClass: self andSelector: #windowSpec"

	&lt;resource: #canvas&gt;
	^#(#{UI.FullSpec} 
		#window: 
		#(#{UI.WindowSpec} 
			#label: #(#{Kernel.UserMessage} #key: #OpentalkMonitor #defaultString: 'Opentalk Monitor' #catalogID: #opentalktools) 
			#min: #(#{Core.Point} 400 400 ) 
			#max: #(#{Core.Point} 0 0 ) 
			#bounds: #(#{Graphics.Rectangle} 275 190 948 690 ) 
			#flags: 4 
			#menu: #menuBar ) 
		#component: 
		#(#{UI.SpecCollection} 
			#collection: #(
				#(#{UI.SubCanvasSpec} 
					#layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 -2 0.333333 ) 
					#name: #components 
					#flags: 0 
					#majorKey: #{ComponentListSubcanvas} 
					#minorKey: #windowSpec 
					#clientKey: #componentListSubcanvas ) 
				#(#{UI.ResizingSplitterSpec} 
					#layout: #(#{Graphics.LayoutFrame} 0 0 -2 0.333333 0 1 2 0.333333 ) 
					#name: #compEvsSplitter 
					#horizontal: true 
					#minAboveSize: 30 
					#minBelowSize: 30 
					#aboveWidgets: 'components' 
					#belowWidgets: 'eventLog' ) 
				#(#{UI.CompositeSpecCollection} 
					#collection: #(
						#(#{UI.ResizingSplitterSpec} 
							#layout: #(#{Graphics.LayoutFrame} 0 0 -2 0.5 0 1 2 0.5 ) 
							#name: #evsLogSplitter 
							#horizontal: true 
							#minAboveSize: 30 
							#minBelowSize: 30 
							#aboveWidgets: 'events' 
							#belowWidgets: 'log' ) 
						#(#{UI.SubCanvasSpec} 
							#layout: #(#{Graphics.LayoutFrame} 0 0 2 0.5 0 1 0 1 ) 
							#name: #log 
							#flags: 0 
							#majorKey: #{EventListSubcanvas} 
							#minorKey: #windowSpec 
							#clientKey: #eventListSubcanvas ) 
						#(#{UI.SubCanvasSpec} 
							#layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 -2 0.5 ) 
							#name: #events 
							#flags: 0 
							#majorKey: #{EventSubscriptionSubcanvas} 
							#minorKey: #windowSpec 
							#clientKey: #eventSubscriptionSubcanvas ) ) 
					#compositeSpec: 
					#(#{UI.CompositeSpec} 
						#layout: #(#{Graphics.LayoutFrame} 0 0 2 0.333333 0 1 0 1 ) 
						#name: #eventLog ) ) ) ) )</body>
</methods>

<methods>
<class-id>Opentalk.OpentalkMonitor class</class-id> <category>resources</category>

<body package="Opentalk-Tools-Monitor" selector="menuBar">menuBar
	"Tools.MenuEditor new openOnClass: self andSelector: #menuBar"

	&lt;resource: #menu&gt;
	^#(#{UI.Menu} #(
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #_Monitor #defaultString: '&amp;Monitor' #catalogID: #opentalktools) 
				#nameKey: #monitor 
				#submenu: #(#{UI.Menu} #(
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_Refresh #defaultString: '&amp;Refresh' #catalogID: #opentalktools) 
							#nameKey: #refreshMonitor 
							#value: #refreshMonitor ) ) #(1 ) nil ) ) 
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #_BrokerAdaptor #defaultString: '&amp;Broker/Adaptor' #catalogID: #opentalktools) 
				#submenu: #(#{UI.Menu} #(
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #Star_t #defaultString: 'Star&amp;t' #catalogID: #opentalktools) 
							#nameKey: #startComponent 
							#value: #startComponent ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #Sto_p #defaultString: 'Sto&amp;p' #catalogID: #opentalktools) 
							#nameKey: #stopComponent 
							#value: #stopComponent ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #I_ncrementPort #defaultString: 'I&amp;ncrement port' #catalogID: #opentalktools) 
							#nameKey: #incrementComponentPort 
							#value: #incrementComponentPort ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #D_ecrementPort #defaultString: 'D&amp;ecrement port' #catalogID: #opentalktools) 
							#nameKey: #decrementComponentPort 
							#value: #decrementComponentPort ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_Inspect #defaultString: '&amp;Inspect' #catalogID: #opentalktools) 
							#nameKey: #inspectComponent 
							#value: #inspectComponent ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_Remove #defaultString: '&amp;Remove' #catalogID: #opentalktools) 
							#nameKey: #removeComponent 
							#value: #removeComponent ) ) #(2 2 1 1 ) nil ) ) 
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #Event_Subscription #defaultString: 'Event &amp;Subscription' #catalogID: #opentalktools) 
				#submenu: #(#{UI.Menu} #(
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_SelectAll #defaultString: '&amp;Select all' #catalogID: #opentalktools) 
							#nameKey: #selectAllSubscriptions 
							#value: #selectAllSubscriptions ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_UnselectAll #defaultString: '&amp;Unselect all' #catalogID: #opentalktools) 
							#nameKey: #unselectAllSubscriptions 
							#value: #unselectAllSubscriptions ) ) #(2 ) nil ) ) 
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #Event_Log #defaultString: 'Event &amp;Log' #catalogID: #opentalktools) 
				#submenu: #(#{UI.Menu} #(
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_ClearAll #defaultString: '&amp;Clear all' #catalogID: #opentalktools) 
							#nameKey: #clearAllLogItems 
							#value: #clearAllLogItems ) 
						#(#{UI.MenuItem} 
							#rawLabel: #(#{Kernel.UserMessage} #key: #_InspectItem #defaultString: '&amp;Inspect item' #catalogID: #opentalktools) 
							#nameKey: #inspectLogItem 
							#value: #inspectLogItem ) ) #(2 ) nil ) ) ) #(4 ) nil ) decodeAsLiteralArray</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas class</class-id> <category>resources</category>

<body package="Opentalk-Tools-Monitor" selector="logMenu">logMenu
	"Tools.MenuEditor new openOnClass: self andSelector: #logMenu"

	&lt;resource: #menu&gt;
	^#(#{UI.Menu} #(
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #ClearAll #defaultString: 'Clear All' #catalogID: #opentalktools) 
				#nameKey: #clearAll 
				#value: #clearAllLogItems ) 
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #InspectItem #defaultString: 'Inspect Item' #catalogID: #opentalktools) 
				#nameKey: #inspectItem 
				#value: #inspectLogItem ) ) #(2 ) nil ) decodeAsLiteralArray</body>
</methods>

<methods>
<class-id>Opentalk.EventListSubcanvas class</class-id> <category>interface specs</category>

<body package="Opentalk-Tools-Monitor" selector="windowSpec">windowSpec
	"Tools.UIPainter new openOnClass: self andSelector: #windowSpec"

	&lt;resource: #canvas&gt;
	^#(#{UI.FullSpec} 
		#window: 
		#(#{UI.WindowSpec} 
			#label: #(#{Kernel.UserMessage} #key: #EventListSubcanvas #defaultString: 'Event List Subcanvas' #catalogID: #opentalktools) 
			#min: #(#{Core.Point} 742 147 ) 
			#max: #(#{Core.Point} 742 147 ) 
			#bounds: #(#{Graphics.Rectangle} 172 395 914 542 ) ) 
		#component: 
		#(#{UI.SpecCollection} 
			#collection: #(
				#(#{UI.SequenceViewSpec} 
					#layout: #(#{Graphics.LayoutFrame} 0 0 0 0 -132 1 0 1 ) 
					#name: #selectionInList 
					#flags: 15 
					#model: #selectionInList 
					#menu: #logMenu 
					#useModifierKeys: true 
					#selectionType: #highlight ) 
				#(#{UI.CompositeSpecCollection} 
					#collection: #(
						#(#{UI.CheckBoxSpec} 
							#layout: #(#{Core.Point} 0 0 ) 
							#name: #classnameCheckBox 
							#flags: 32 
							#model: #classnameFilterAdaptor 
							#label: #(#{Kernel.UserMessage} #key: #className #defaultString: 'class name' #catalogID: #opentalktools) ) 
						#(#{UI.CheckBoxSpec} 
							#layout: #(#{Core.Point} 0 75 ) 
							#name: #eventCheckBox 
							#flags: 32 
							#model: #eventFilterAdaptor 
							#label: #(#{Kernel.UserMessage} #key: #event #defaultString: 'event' #catalogID: #opentalktools) ) 
						#(#{UI.CheckBoxSpec} 
							#layout: #(#{Core.Point} 0 60 ) 
							#name: #componentCheckBox 
							#flags: 32 
							#model: #componentFilterAdaptor 
							#label: #(#{Kernel.UserMessage} #key: #component #defaultString: 'component' #catalogID: #opentalktools) ) 
						#(#{UI.CheckBoxSpec} 
							#layout: #(#{Core.Point} 0 45 ) 
							#name: #protocolTagCheckBox 
							#flags: 32 
							#model: #protocolTagFilterAdaptor 
							#label: #(#{Kernel.UserMessage} #key: #protocolTag #defaultString: 'protocol tag' #catalogID: #opentalktools) ) 
						#(#{UI.CheckBoxSpec} 
							#layout: #(#{Core.Point} 0 30 ) 
							#name: #portCheckBox 
							#flags: 32 
							#model: #portFilterAdaptor 
							#label: #(#{Kernel.UserMessage} #key: #port #defaultString: 'port' #catalogID: #opentalktools) ) 
						#(#{UI.CheckBoxSpec} 
							#layout: #(#{Core.Point} 0 15 ) 
							#name: #hostAddressCheckBox 
							#flags: 32 
							#model: #hostAddressFilterAdaptor 
							#label: #(#{Kernel.UserMessage} #key: #hostAddress #defaultString: 'host address' #catalogID: #opentalktools) ) ) 
					#compositeSpec: 
					#(#{UI.CompositeSpec} 
						#layout: #(#{Graphics.LayoutFrame} -120 1 10 0 -10 1 -10 1 ) 
						#name: #filterGroup ) ) 
				#(#{UI.GroupBoxSpec} 
					#layout: #(#{Graphics.LayoutFrame} -130 1 0 0 0 1 0 1 ) 
					#name: #GroupBox1 ) ) ) )</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas class</class-id> <category>interface specs</category>

<body package="Opentalk-Tools-Monitor" selector="windowSpec">windowSpec
	"Tools.UIPainter new openOnClass: self andSelector: #windowSpec"

	&lt;resource: #canvas&gt;
	^#(#{UI.FullSpec} 
		#window: 
		#(#{UI.WindowSpec} 
			#label: #(#{Kernel.UserMessage} #key: #EventSubscriptionSubcanvas #defaultString: 'Event Subscription Subcanvas' #catalogID: #opentalktools) 
			#min: #(#{Core.Point} 485 147 ) 
			#max: #(#{Core.Point} 485 147 ) 
			#bounds: #(#{Graphics.Rectangle} 298 315 783 462 ) ) 
		#component: 
		#(#{UI.SpecCollection} 
			#collection: #(
				#(#{UI.SequenceViewSpec} 
					#layout: #(#{Graphics.LayoutFrame} 0 0 0 0 -132 1 0 1 ) 
					#name: #eventSubscriptionSIL 
					#model: #eventSubscriptionSIL 
					#menu: #subscriptionMenu 
					#multipleSelections: true 
					#useModifierKeys: true 
					#selectionType: #checkMark ) 
				#(#{UI.GroupBoxSpec} 
					#layout: #(#{Graphics.LayoutFrame} -130 1 0 0 0 1 0 1 ) 
					#name: #GroupBox1 ) ) ) )</body>
</methods>

<methods>
<class-id>Opentalk.EventSubscriptionSubcanvas class</class-id> <category>resources</category>

<body package="Opentalk-Tools-Monitor" selector="subscriptionMenu">subscriptionMenu
	"Tools.MenuEditor new openOnClass: self andSelector: #subscriptionMenu"

	&lt;resource: #menu&gt;
	^#(#{UI.Menu} #(
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #SelectAll #defaultString: 'Select All' #catalogID: #opentalktools) 
				#nameKey: #selectAll 
				#value: #selectAllSubscriptions ) 
			#(#{UI.MenuItem} 
				#rawLabel: #(#{Kernel.UserMessage} #key: #UnselectAll #defaultString: 'Unselect All' #catalogID: #opentalktools) 
				#nameKey: #unselectAll 
				#value: #unselectAllSubscriptions ) ) #(2 ) nil ) decodeAsLiteralArray</body>
</methods>

<methods>
<class-id>Tools.VisualLauncher</class-id> <category>opentalk</category>

<body package="Opentalk-Tools-Monitor" selector="toolsOpentalkMonitor">toolsOpentalkMonitor

	&lt;menuItem: 'Monitor'
		nameKey: #opentalkMonitor
		menu: #(#menuBar #tools #opentalk)
		position: 20.50&gt;
	
	Opentalk.OpentalkMonitor open</body>
</methods>

<initialize>
<class-id>Opentalk.OpentalkMonitor</class-id>
</initialize>

<do-it>"Imported Classes:"</do-it>

<do-it>self error: 'Attempting to file-in parcel imports.  Choose terminate or close'</do-it>

<class>
<name>Object</name>
<environment>Core</environment>
<super></super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars></inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Kernel-Objects</category>
<attributes>
<package>Kernel-Objects</package>
</attributes>
</class>

<class>
<name>ApplicationModel</name>
<environment>UI</environment>
<super>UI.Model</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>builder uiSession eventHandlers </inst-vars>
<class-inst-vars>savedWindowInformation </class-inst-vars>
<imports></imports>
<category>UIBuilder-Framework</category>
<attributes>
<package>UIBuilder-Framework</package>
</attributes>
</class>

<class>
<name>VisualLauncher</name>
<environment>Tools</environment>
<super>UI.ApplicationModel</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>menuBar toolBar textCollector toolDock </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Tools-Misc</category>
<attributes>
<package>Tools-Misc</package>
</attributes>
</class>

<class>
<name>FilterableListSubcanvas</name>
<environment>Opentalk</environment>
<super>UI.ApplicationModel</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>selectionInList selectionHolder selectionIndexHolder unfilteredList filteredList filter filters filterList filterKey </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Tools-Basic</category>
<attributes>
<package>Opentalk-Tools-Basic</package>
</attributes>
</class>

<class>
<name>Message</name>
<environment>Core</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>selector args </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Kernel-Methods</category>
<attributes>
<package>Kernel-Methods</package>
</attributes>
</class>

<class>
<name>GenericProtocol</name>
<environment>Opentalk</environment>
<super>Core.EventManager</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>state </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk-Core</category>
<attributes>
<package>Opentalk-Core</package>
</attributes>
</class>

<class>
<name>MessageSend</name>
<environment>Core</environment>
<super>Core.Message</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>receiver </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Kernel-Methods</category>
<attributes>
<package>Kernel-Methods</package>
</attributes>
</class>

<class>
<name>EventCollector</name>
<environment>Protocols</environment>
<super>Protocols.EventPrinter</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>events baseClockValue </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category>Opentalk</category>
<attributes>
<package>Protocols-Common</package>
</attributes>
</class>

</st-source>