| 
					
				 | 
			
			
				@@ -220,9 +220,9 @@ selector: "renderContentOn:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'rendering', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (html){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $HLVerticalSplitter(){return smalltalk.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $HLHorizontalSplitter(){return smalltalk.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 function $HLContainer(){return smalltalk.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $HLHorizontalSplitter(){return smalltalk.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $HLVerticalSplitter(){return smalltalk.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(html)._with_(_st($HLContainer())._with_(_st($HLHorizontalSplitter())._with_with_(_st($HLVerticalSplitter())._with_with_(_st($HLVerticalSplitter())._with_with_(self._packagesListWidget(),self._classesListWidget()),_st($HLVerticalSplitter())._with_with_(self._protocolsListWidget(),self._methodsListWidget())),self._sourceWidget()))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._packagesListWidget())._focus(); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -230,7 +230,7 @@ return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},sm 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderContentOn: html\x0a\x09html with: (HLContainer with: (HLHorizontalSplitter \x0a    \x09with: (HLVerticalSplitter\x0a        \x09with: (HLVerticalSplitter\x0a            \x09with: self packagesListWidget\x0a                with: self classesListWidget)\x0a            with: (HLVerticalSplitter\x0a            \x09with: self protocolsListWidget\x0a                with: self methodsListWidget)) \x0a        with: self sourceWidget)).\x0a\x09\x0a\x09self packagesListWidget focus", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 messageSends: ["with:", "with:with:", "packagesListWidget", "classesListWidget", "protocolsListWidget", "methodsListWidget", "sourceWidget", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["HLVerticalSplitter", "HLHorizontalSplitter", "HLContainer"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowser); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -257,7 +257,7 @@ return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"sourceWidget",{},smalltalk.HLBrowser)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "sourceWidget\x0a\x09^ sourceWidget ifNil: [\x0a      \x09sourceWidget := HLBrowserBottomWidget new\x0a\x09\x09\x09model: self model;\x0a\x09\x09\x09yourself ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:", "model:", "model", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:", "model:", "new", "model", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLBrowserBottomWidget"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowser); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -273,7 +273,7 @@ smalltalk.HLWidget.fn.prototype._unregister.apply(_st(self), []); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st([self._packagesListWidget(),self._classesListWidget(),self._protocolsListWidget(),self._methodsListWidget(),self._sourceWidget()])._do_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(each)._unregister(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},smalltalk.HLBrowser)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "unregister\x0a\x09super unregister.\x0a\x0a\x09{ \x0a\x09\x09self packagesListWidget.\x0a\x09\x09self classesListWidget.\x0a\x09\x09self protocolsListWidget.\x0a\x09\x09self methodsListWidget.\x0a\x09\x09self sourceWidget\x0a\x09} \x0a\x09\x09do: [ :each | each unregister ]", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -414,7 +414,7 @@ return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"codeWidget",{},smalltalk.HLBrowserBottomWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "codeWidget\x0a\x09^ codeWidget ifNil: [ codeWidget := HLBrowserCodeWidget new\x0a\x09\x09browserModel: self model;\x0a\x09\x09yourself ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:", "browserModel:", "model", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:", "browserModel:", "new", "model", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLBrowserCodeWidget"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserBottomWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -442,7 +442,7 @@ return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"documentationWidget",{},smalltalk.HLBrowserBottomWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "documentationWidget\x0a\x09^ documentationWidget ifNil: [ documentationWidget := HLDocumentationWidget new\x0a\x09\x09model: self model;\x0a\x09\x09yourself ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:", "model:", "model", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:", "model:", "new", "model", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLDocumentationWidget"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserBottomWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -598,7 +598,7 @@ _st(html)._with_(self._codeWidget()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLBrowserBottomWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderContentOn: html\x0a\x09self model showComment \x0a\x09\x09ifTrue: [ self renderPanesOn: html ]\x0a\x09\x09ifFalse: [ html with: self codeWidget ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifTrue:ifFalse:", "renderPanesOn:", "with:", "codeWidget", "showComment", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifTrue:ifFalse:", "showComment", "model", "renderPanesOn:", "with:", "codeWidget"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserBottomWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -635,7 +635,7 @@ _st(self._announcer())._announce_(_st($HLEditComment())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"editComment",{},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "editComment\x0a\x09self announcer announce: HLEditComment new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLEditComment"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -652,7 +652,7 @@ _st(self._announcer())._announce_(_st($HLClassesFocusRequested())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusOnClasses",{},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusOnClasses\x0a\x09self announcer announce: HLClassesFocusRequested new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLClassesFocusRequested"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -669,7 +669,7 @@ _st(self._announcer())._announce_(_st($HLMethodsFocusRequested())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusOnMethods",{},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusOnMethods\x0a\x09self announcer announce: HLMethodsFocusRequested new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLMethodsFocusRequested"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -686,7 +686,7 @@ _st(self._announcer())._announce_(_st($HLPackagesFocusRequested())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusOnPackages",{},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusOnPackages\x0a\x09self announcer announce: HLPackagesFocusRequested new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLPackagesFocusRequested"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -703,7 +703,7 @@ _st(self._announcer())._announce_(_st($HLProtocolsFocusRequested())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusOnProtocols",{},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusOnProtocols\x0a\x09self announcer announce: HLProtocolsFocusRequested new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLProtocolsFocusRequested"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -720,7 +720,7 @@ _st(self._announcer())._announce_(_st($HLSourceCodeFocusRequested())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusOnSourceCode",{},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusOnSourceCode\x0a\x09self announcer announce: HLSourceCodeFocusRequested new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLSourceCodeFocusRequested"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -752,7 +752,7 @@ _st(self._environment())._setClassCommentOf_to_(_st(self._selectedClass())._theN 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"setClassComment:",{aString:aString},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "setClassComment: aString\x0a\x09self environment\x0a\x09\x09setClassCommentOf: self selectedClass theNonMetaClass\x0a\x09\x09to: aString", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["setClassCommentOf:to:", "theNonMetaClass", "selectedClass", "environment"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["setClassCommentOf:to:", "environment", "theNonMetaClass", "selectedClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -793,11 +793,11 @@ return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 self["@showComment"]=aBoolean; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 self["@showComment"]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(self._announcer())._announce_(_st($HLShowCommentToggled())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"showComment:",{aBoolean:aBoolean},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aBoolean"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "showComment: aBoolean\x0a\x09self withChangesDo: [\x0a\x09\x09showComment := aBoolean.\x0a\x09\x09self announcer announce: HLShowCommentToggled new ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["withChangesDo:", "announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["withChangesDo:", "announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLShowCommentToggled"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -852,11 +852,11 @@ $3=_st(self._selectedClass())._theMetaClass(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($2)._selectedClass_($3); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(self._announcer())._announce_(_st($HLShowInstanceToggled())._new()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"showInstance:",{aBoolean:aBoolean},smalltalk.HLBrowserModel)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aBoolean"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "showInstance: aBoolean\x0a\x0a\x09self withChangesDo: [\x0a\x09\x09showInstance := aBoolean.\x0a\x0a    \x09self selectedClass ifNotNil: [\x0a    \x09\x09self selectedClass: (aBoolean\x0a    \x09\x09\x09ifTrue: [self selectedClass theNonMetaClass ]\x0a\x09    \x09  \x09ifFalse: [ self selectedClass theMetaClass ]) ].\x0a    \x0a\x09\x09self announcer announce: HLShowInstanceToggled new ] ", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["withChangesDo:", "ifNotNil:", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "selectedClass", "theMetaClass", "announce:", "new", "announcer"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["withChangesDo:", "ifNotNil:", "selectedClass", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "theMetaClass", "announce:", "announcer", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLShowInstanceToggled"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLBrowserModel); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -899,11 +899,11 @@ $1=_st(self._selectorsCache())._cacheFor_(each); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($1)._removeSelector_(aSelector); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=_st($1)._invalidateChildrenSelector_(aSelector); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"invalidateChildrenSelector:",{aSelector:aSelector},smalltalk.HLClassCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSelector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "invalidateChildrenSelector: aSelector\x0a\x09self theClass subclasses do: [ :each |\x0a    \x09(self selectorsCache cacheFor: each)\x0a        \x09removeSelector: aSelector;\x0a        \x09invalidateChildrenSelector: aSelector ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["do:", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateChildrenSelector:", "subclasses", "theClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["do:", "subclasses", "theClass", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateChildrenSelector:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassCache); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -928,7 +928,7 @@ $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"invalidateParentSelector:",{aSelector:aSelector},smalltalk.HLClassCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSelector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "invalidateParentSelector: aSelector\x0a\x09self theClass superclass ifNotNil: [\x0a    \x09(self selectorsCache cacheFor: self theClass superclass)\x0a        \x09removeSelector: aSelector;\x0a\x09\x09\x09invalidateParentSelector: aSelector ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNotNil:", "removeSelector:", "cacheFor:", "superclass", "theClass", "selectorsCache", "invalidateParentSelector:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNotNil:", "superclass", "theClass", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateParentSelector:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassCache); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -964,12 +964,12 @@ var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(self._overriddenCache())._at_ifAbsentPut_(_st(aMethod)._selector(),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(aMethod)._isOverridden(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"isOverridden:",{aMethod:aMethod},smalltalk.HLClassCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aMethod"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "isOverridden: aMethod\x0a\x09^ self overriddenCache \x0a    \x09at: aMethod selector\x0a      \x09ifAbsentPut: [ aMethod isOverridden ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["at:ifAbsentPut:", "selector", "isOverridden", "overriddenCache"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["at:ifAbsentPut:", "overriddenCache", "selector", "isOverridden"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassCache); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -985,12 +985,12 @@ var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(self._overrideCache())._at_ifAbsentPut_(_st(aMethod)._selector(),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(aMethod)._isOverride(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"isOverride:",{aMethod:aMethod},smalltalk.HLClassCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aMethod"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "isOverride: aMethod\x0a\x09^ self overrideCache\x0a    \x09at: aMethod selector\x0a      \x09ifAbsentPut: [ aMethod isOverride ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["at:ifAbsentPut:", "selector", "isOverride", "overrideCache"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["at:ifAbsentPut:", "overrideCache", "selector", "isOverride"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassCache); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1054,10 +1054,10 @@ var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._overriddenCache())._removeKey_ifAbsent_(aSelector,(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._overrideCache())._removeKey_ifAbsent_(aSelector,(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"removeSelector:",{aSelector:aSelector},smalltalk.HLClassCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSelector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "removeSelector: aSelector\x0a\x09self overriddenCache \x0a    \x09removeKey: aSelector\x0a        ifAbsent: [ ].\x0a    self overrideCache \x0a    \x09removeKey: aSelector\x0a        ifAbsent: [ ]", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1193,7 +1193,7 @@ _st(_st(self._model())._announcer())._announce_(_st($HLMethodsListFocus())._new( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusMethodsListWidget",{},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusMethodsListWidget\x0a\x09self model announcer announce: HLMethodsListFocus new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "model", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLMethodsListFocus"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1210,7 +1210,7 @@ _st(_st(self._model())._announcer())._announce_(_st($HLProtocolsListFocus())._ne 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusProtocolsListWidget",{},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusProtocolsListWidget\x0a\x09self model announcer announce: HLProtocolsListFocus new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "model", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLProtocolsListFocus"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1226,12 +1226,12 @@ var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(self._items())._select_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(_st(each)._superclass()).__eq(aClass); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"getChildrenOf:",{aClass:aClass},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "getChildrenOf: aClass\x0a\x09^ self items select: [ :each | each superclass = aClass ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["select:", "=", "superclass", "items"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["select:", "items", "=", "superclass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1247,7 +1247,7 @@ var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(aCollection)._select_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(_st(aCollection)._includes_(_st(each)._superclass()))._not(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"getRootClassesOf:",{aCollection:aCollection},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aCollection"], 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1342,7 +1342,7 @@ class_=_st(anAnnouncement)._theClass(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(_st(_st(class_)._package()).__eq(_st(self._model())._selectedPackage()))._or_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(self._items())._includes_(class_); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(! smalltalk.assert($1)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=self; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $2; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1352,7 +1352,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{anAnnouncement:anAnnouncement,class_:class_},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassAdded: anAnnouncement\x0a\x09| class |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09\x0a\x09(class package = self model selectedPackage or: [\x0a\x09\x09self items includes: class ]) ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["theClass", "ifFalse:", "or:", "includes:", "items", "=", "selectedPackage", "model", "package", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["theClass", "ifFalse:", "or:", "=", "package", "selectedPackage", "model", "includes:", "items", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1376,7 +1376,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassCommentChanged:",{anAnnouncement:anAnnouncement,class_:class_},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassCommentChanged: anAnnouncement\x0a\x09| class |\x0a\x09class := anAnnouncement theClass.\x0a\x0a\x09class package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["theClass", "ifFalse:", "=", "selectedPackage", "model", "package", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["theClass", "ifFalse:", "=", "package", "selectedPackage", "model", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1406,7 +1406,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassMigrated:",{anAnnouncement:anAnnouncement,class_:class_,oldClass:oldClass},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassMigrated: anAnnouncement\x0a\x09| class oldClass |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09oldClass := anAnnouncement oldClass.\x0a\x0a\x09(self items includes: oldClass) ifFalse: [ ^ self ].\x0a\x0a\x09self model selectedClass = oldClass ifTrue: [\x0a\x09\x09self model selectedClass: class ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["theClass", "oldClass", "ifFalse:", "includes:", "items", "ifTrue:", "selectedClass:", "model", "=", "selectedClass", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["theClass", "oldClass", "ifFalse:", "includes:", "items", "ifTrue:", "=", "selectedClass", "model", "selectedClass:", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1425,7 +1425,7 @@ oldPackage=_st(anAnnouncement)._oldPackage(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(_st(oldPackage).__eq(_st(self._model())._selectedPackage()))._or_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(_st(class_)._package()).__eq(_st(self._model())._selectedPackage()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(! smalltalk.assert($1)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=self; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $2; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1467,7 +1467,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassRemoved:",{anAnnouncement:anAnnouncement,class_:class_},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassRemoved: anAnnouncement\x0a\x09| class |\x0a\x09class := anAnnouncement theClass.\x0a\x0a\x09class package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["theClass", "ifFalse:", "=", "selectedPackage", "model", "package", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["theClass", "ifFalse:", "=", "package", "selectedPackage", "model", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1490,7 +1490,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassRenamed:",{anAnnouncement:anAnnouncement},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassRenamed: anAnnouncement\x0a\x09anAnnouncement theClass package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:", "=", "selectedPackage", "model", "package", "theClass", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:", "=", "package", "theClass", "selectedPackage", "model", "setItemsForSelectedPackage", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1523,7 +1523,7 @@ $5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement,selectedClass:selectedClass},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassSelected: anAnnouncement\x0a\x09| selectedClass |\x0a\x09\x0a\x09anAnnouncement item ifNil: [ ^ self ].\x0a\x09\x0a\x09selectedClass := anAnnouncement item theNonMetaClass.\x0a\x09self selectedItem: selectedClass.\x0a\x0a\x09self hasFocus ifFalse: [\x0a\x09\x09self \x0a\x09\x09\x09activateItem: selectedClass;\x0a\x09\x09\x09focus ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:", "item", "theNonMetaClass", "selectedItem:", "ifFalse:", "activateItem:", "focus", "hasFocus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:", "item", "theNonMetaClass", "selectedItem:", "ifFalse:", "hasFocus", "activateItem:", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1616,12 +1616,12 @@ $4=self._showInstance(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(smalltalk.assert($4)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(str)._nextPutAll_(" active"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2,2)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($3)._with_("Instance"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $5=_st($3)._onClick_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._showInstance_(true); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $6=_st(html)._button(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($6)._class_(_st($String())._streamContents_((function(str){ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1631,14 +1631,14 @@ $7=self._showClass(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(smalltalk.assert($7)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(str)._nextPutAll_(" active"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2,5)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($6)._with_("Class"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $8=_st($6)._onClick_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._showInstance_(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,7)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $8; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $9=_st(html)._label(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($9)._class_("checkbox"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $10=_st($9)._with_((function(){ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1648,11 +1648,11 @@ _st($11)._type_("checkbox"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $12=_st($11)._onClick_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._toggleShowComment(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,9)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 checkbox=$12; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 checkbox; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(html)._with_("Doc"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,8)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $13=self._showComment(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(smalltalk.assert($13)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(checkbox)._at_put_("checked","checked"); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1660,7 +1660,7 @@ _st(checkbox)._at_put_("checked","checked"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html,checkbox:checkbox},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderButtonsOn: html\x0a\x09| checkbox |\x0a\x09\x0a\x09html div \x0a        class: 'btn-group';\x0a\x09\x09with: [ \x0a           \x09html button \x0a                class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showInstance ifTrue: [ \x0a                    \x09str nextPutAll: ' active' ] ]);\x0a  \x09\x09\x09\x09with: 'Instance';\x0a                onClick: [ self showInstance: true ].\x0a  \x09\x09\x09html button\x0a  \x09\x09\x09\x09class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showClass ifTrue: [ \x0a                    \x09str nextPutAll: ' active' ] ]);\x0a  \x09\x09\x09\x09with: 'Class';\x0a\x09\x09\x09\x09onClick: [ self showInstance: false ] ].\x0a\x09\x09html label \x0a\x09\x09\x09class: 'checkbox';\x0a\x09\x09\x09with: [\x0a\x09\x09\x09\x09checkbox := html input\x0a\x09\x09\x09\x09\x09type: 'checkbox';\x0a\x09\x09\x09\x09\x09onClick: [ self toggleShowComment ].\x0a\x09\x09\x09\x09html with: 'Doc' ].\x0a\x09\x09\x09\x09\x0a\x09\x09self showComment ifTrue: [\x0a\x09\x09\x09checkbox at: 'checked' put: 'checked' ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["class:", "div", "with:", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "button", "onClick:", "showInstance:", "showClass", "label", "type:", "input", "toggleShowComment", "at:put:", "showComment"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["class:", "div", "with:", "button", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "onClick:", "showInstance:", "showClass", "label", "type:", "input", "toggleShowComment", "showComment", "at:put:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["String"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1686,21 +1686,21 @@ _st($3)._with_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(_st(html)._tag_("i"))._class_(self._cssClassForItem_(aClass)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._renderItemLabel_level_on_(aClass,anInteger,html); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $4=_st($3)._onClick_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._activateListItem_(_st(li)._asJQuery()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._getChildrenOf_(aClass))._do_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._renderItem_level_on_(each,_st(anInteger).__plus((1)),html); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,4)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderItem:level:on:",{aClass:aClass,anInteger:anInteger,html:html,li:li},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aClass", "anInteger", "html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderItem: aClass level: anInteger on: html\x0a\x09| li |\x0a    \x0a\x09li := html li.\x0a\x09self registerMappingFrom: aClass to: li.\x0a\x09\x0a    li\x0a    \x09at: 'list-data' put: (self items indexOf: aClass);\x0a\x09\x09class: (self listCssClassForItem: aClass);\x0a\x09\x09with: [ \x0a        \x09html a\x0a            \x09with: [ \x0a            \x09\x09(html tag: 'i') class: (self cssClassForItem: aClass).\x0a  \x09\x09\x09\x09\x09self renderItemLabel: aClass level: anInteger on: html ];\x0a\x09\x09\x09\x09onClick: [\x0a                  \x09self activateListItem: li asJQuery ] ].\x0a                    \x0a    (self getChildrenOf: aClass) do: [ :each |\x0a    \x09self renderItem: each level: anInteger + 1 on: html ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["li", "registerMappingFrom:to:", "at:put:", "indexOf:", "items", "class:", "listCssClassForItem:", "with:", "cssClassForItem:", "tag:", "renderItemLabel:level:on:", "a", "onClick:", "activateListItem:", "asJQuery", "do:", "renderItem:level:on:", "+", "getChildrenOf:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["li", "registerMappingFrom:to:", "at:put:", "indexOf:", "items", "class:", "listCssClassForItem:", "with:", "a", "tag:", "cssClassForItem:", "renderItemLabel:level:on:", "onClick:", "activateListItem:", "asJQuery", "do:", "getChildrenOf:", "renderItem:level:on:", "+"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1716,11 +1716,11 @@ smalltalk.HLToolListWidget.fn.prototype._renderItem_on_.apply(_st(self), [aClass 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._getChildrenOf_(aClass))._do_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._renderItem_level_on_(each,(1),html); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderItem:on:",{aClass:aClass,html:html},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aClass", "html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderItem: aClass on: html\x0a\x09super renderItem: aClass on: html.\x0a    (self getChildrenOf: aClass) do: [ :each |\x0a    \x09self renderItem: each level: 1 on: html ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["renderItem:on:", "do:", "renderItem:level:on:", "getChildrenOf:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["renderItem:on:", "do:", "getChildrenOf:", "renderItem:level:on:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1738,13 +1738,13 @@ return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(anInteger)._timesRepeat_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(str)._nextPutAll_("    "); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(str)._nextPutAll_(_st(aClass)._name()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({str:str},$ctx1)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({str:str},$ctx1,1)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:level:on:",{aClass:aClass,anInteger:anInteger,html:html},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aClass", "anInteger", "html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderItemLabel: aClass level: anInteger on: html\x0a\x09html span asJQuery html: (String streamContents: [ :str |\x0a\x09\x09anInteger timesRepeat: [\x0a\x09\x09\x09str nextPutAll: '    '].\x0a\x09\x09\x09str nextPutAll: aClass name ])", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["html:", "streamContents:", "timesRepeat:", "nextPutAll:", "name", "asJQuery", "span"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["html:", "asJQuery", "span", "streamContents:", "timesRepeat:", "nextPutAll:", "name"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["String"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1775,11 +1775,11 @@ return smalltalk.withContext(function($ctx1) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._getRootClassesOf_(self._items()))._do_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._renderItem_on_(each,html); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderListOn:",{html:html},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderListOn: html\x0a\x09(self getRootClassesOf: self items)\x0a    \x09do: [ :each | self renderItem: each on: html ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["do:", "renderItem:on:", "getRootClassesOf:", "items"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["do:", "getRootClassesOf:", "items", "renderItem:on:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1816,16 +1816,16 @@ $2=[]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=_st(_st(_st(_st(_st(aPackage)._classes())._collect_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(each)._theNonMetaClass(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})))._asSet())._asArray())._sort_((function(a,b){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})})))._asSet())._asArray())._sort_((function(a,b){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(_st(a)._name()).__lt(_st(b)._name()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,4)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($1)._items_($2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"setItemsForPackage:",{aPackage:aPackage},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aPackage"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "setItemsForPackage: aPackage\x0a\x09self items: (aPackage \x0a    \x09ifNil: [ #() ]\x0a  \x09\x09ifNotNil: [ ((aPackage classes \x0a        \x09collect: [ :each | each theNonMetaClass ]) asSet asArray) \x0a            \x09sort: [:a :b | a name < b name ] ]).", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["items:", "ifNil:ifNotNil:", "sort:", "<", "name", "asArray", "asSet", "collect:", "theNonMetaClass", "classes"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["items:", "ifNil:ifNotNil:", "sort:", "asArray", "asSet", "collect:", "classes", "theNonMetaClass", "<", "name"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1943,7 +1943,7 @@ _st(self._model())._showComment_(_st(self._showComment())._not()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"toggleShowComment",{},smalltalk.HLClassesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "toggleShowComment\x0a\x09self model showComment: self showComment not", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["showComment:", "not", "showComment", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["showComment:", "model", "not", "showComment"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLClassesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2000,13 +2000,13 @@ item=$receiver; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(_st(item)._comment())._ifEmpty_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._defaultDocumentation(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"documentation",{},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "documentation\x0a\x09^ self selectedItem \x0a\x09\x09ifNil: [ '' ]\x0a\x09\x09ifNotNil: [ :item | item comment ifEmpty: [ self defaultDocumentation ] ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:ifNotNil:", "ifEmpty:", "defaultDocumentation", "comment", "selectedItem"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:ifNotNil:", "selectedItem", "ifEmpty:", "comment", "defaultDocumentation"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLDocumentationWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2047,7 +2047,7 @@ return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"head",{},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "head\x0a\x09^ self selectedItem \x0a\x09\x09ifNil: [ self defaultHead ]\x0a\x09\x09ifNotNil: [ :item | item name ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:ifNotNil:", "defaultHead", "name", "selectedItem"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:ifNotNil:", "selectedItem", "defaultHead", "name"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLDocumentationWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2143,7 +2143,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassCommentChanged:",{anAnnouncement:anAnnouncement},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassCommentChanged: anAnnouncement\x0a\x09anAnnouncement theClass = self model selectedClass theNonMetaClass\x0a\x09\x09ifTrue: [ self refresh ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifTrue:", "refresh", "=", "theNonMetaClass", "selectedClass", "model", "theClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifTrue:", "=", "theClass", "theNonMetaClass", "selectedClass", "model", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLDocumentationWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2174,7 +2174,7 @@ return smalltalk.withContext(function($ctx1) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 self._request_value_do_(_st(_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name()).__comma(" comment"),_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._comment(),(function(comment){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._setClassComment_(comment); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({comment:comment},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({comment:comment},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onEditDocumentation",{},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onEditDocumentation\x0a\x09self \x0a\x09\x09request: self model selectedClass theNonMetaClass name, ' comment'\x0a\x09\x09value: self model selectedClass theNonMetaClass comment\x0a\x09\x09do: [ :comment | self setClassComment: comment ]", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2199,7 +2199,7 @@ $3=self; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($3)._renderHeadOn_(html); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $4=_st($3)._renderDocOn_(html); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderContentOn: html\x0a\x09html div \x0a\x09\x09class: 'doc';\x0a\x09\x09with: [\x0a\x09\x09\x09self \x0a\x09\x09\x09\x09renderHeadOn: html;\x0a\x09\x09\x09\x09renderDocOn: html ]", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2232,9 +2232,9 @@ _st($4)._with_("Edit"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $5=_st($4)._onClick_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._editDocumentation(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $6=_st(html)._div(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($6)._class_("markdown"); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2244,7 +2244,7 @@ _st($7)._html_(_st(_st(_st($Showdown())._at_("converter"))._new())._makeHtml_(se 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderDocOn:",{html:html},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderDocOn: html\x0a\x09self selectedItem ifNotNil: [\x0a\x09\x09self renderInheritanceOn: html.\x0a\x09\x09html h1 \x0a\x09\x09\x09with: 'Overview';\x0a\x09\x09\x09with: [ \x0a\x09\x09\x09\x09html button\x0a\x09\x09\x09\x09\x09class: 'button default';\x0a\x09\x09\x09\x09\x09with: 'Edit';\x0a\x09\x09\x09\x09\x09onClick: [ self editDocumentation ] ].\x0a\x09\x09(html div \x0a\x09\x09\x09class: 'markdown';\x0a\x09\x09\x09asJQuery) html: ((Showdown at: 'converter') new makeHtml: self documentation) ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNotNil:", "renderInheritanceOn:", "with:", "h1", "class:", "button", "onClick:", "editDocumentation", "html:", "makeHtml:", "documentation", "new", "at:", "div", "asJQuery", "selectedItem"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNotNil:", "selectedItem", "renderInheritanceOn:", "with:", "h1", "class:", "button", "onClick:", "editDocumentation", "html:", "div", "asJQuery", "makeHtml:", "new", "at:", "documentation"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["Showdown"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLDocumentationWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2290,14 +2290,14 @@ _st($4)._with_(_st(_st(self._selectedItem())._superclass())._name()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $5=_st($4)._onClick_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._selectClass_(_st(self._selectedItem())._superclass()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderInheritanceOn:",{html:html},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderInheritanceOn: html\x0a\x09html div \x09\x0a\x09\x09class: 'inheritance';\x0a\x09\x09with: [\x0a\x09\x09\x09html with: 'Subclass of '.\x0a\x09\x09\x09self selectedItem superclass \x0a\x09\x09\x09\x09ifNil: [ html em with: 'nil' ]\x0a\x09\x09\x09\x09ifNotNil: [\x0a\x09\x09\x09\x09\x09html a \x0a\x09\x09\x09\x09\x09\x09with: self selectedItem superclass name;\x0a\x09\x09\x09\x09\x09\x09onClick: [ self selectClass: self selectedItem superclass ] ] ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["class:", "div", "with:", "ifNil:ifNotNil:", "em", "name", "superclass", "selectedItem", "a", "onClick:", "selectClass:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["class:", "div", "with:", "ifNil:ifNotNil:", "superclass", "selectedItem", "em", "a", "name", "onClick:", "selectClass:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLDocumentationWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2338,7 +2338,7 @@ return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"selectedItem",{},smalltalk.HLDocumentationWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "selectedItem\x0a\x09^ self model selectedClass ifNotNil: [ :class | class theNonMetaClass ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNotNil:", "theNonMetaClass", "selectedClass", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNotNil:", "selectedClass", "model", "theNonMetaClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLDocumentationWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2529,7 +2529,7 @@ return $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"methodsInProtocol:",{aString:aString},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "methodsInProtocol: aString\x0a\x09self model selectedClass ifNil: [ ^ #() ].\x0a    \x0a\x09^ aString = self allProtocol\x0a    \x09ifTrue: [ self model selectedClass methods ]\x0a      \x09ifFalse: [ self model selectedClass methodsInProtocol: aString ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:", "selectedClass", "model", "ifTrue:ifFalse:", "methods", "methodsInProtocol:", "=", "allProtocol"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:", "selectedClass", "model", "ifTrue:ifFalse:", "=", "allProtocol", "methods", "methodsInProtocol:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2604,7 +2604,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onMethodAdded:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onMethodAdded: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement method methodClass ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedProtocol.\x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:", "=", "methodClass", "method", "selectedClass", "model", "setItemsForSelectedProtocol", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:", "=", "selectedClass", "model", "methodClass", "method", "setItemsForSelectedProtocol", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2634,7 +2634,7 @@ $5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onMethodMoved:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onMethodMoved: anAnnouncement\x0a\x09self model selectedMethod = anAnnouncement method ifFalse: [ ^ self ].\x0a    \x0a\x09self model selectedProtocol = self model allProtocol ifFalse: [\x0a\x09\x09self \x0a\x09\x09\x09selectedItem: nil; \x0a\x09\x09\x09selectItem: nil;\x0a\x09\x09\x09setItemsForSelectedProtocol;\x0a    \x09\x09refresh ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:", "=", "method", "selectedMethod", "model", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh", "allProtocol", "selectedProtocol"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:", "=", "selectedMethod", "model", "method", "selectedProtocol", "allProtocol", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2654,11 +2654,11 @@ method=_st(anAnnouncement)._method(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self._items())._detect_ifNone_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(each).__eq(_st(method)._selector()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=self; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 throw $early=[$1]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=self._selectedItem(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(($receiver = $2) == nil || $receiver == undefined){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2666,7 +2666,7 @@ $2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3=_st(_st(_st(method)._methodClass()).__eq(_st(self._model())._selectedClass()))._and_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(_st(method)._selector()).__eq(self._selectedItem()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(smalltalk.assert($3)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $4=self; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($4)._selectedItem_(nil); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2681,7 +2681,7 @@ catch(e) {if(e===$early)return e[0]; throw e} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"onMethodRemoved:",{anAnnouncement:anAnnouncement,method:method},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onMethodRemoved: anAnnouncement\x0a\x09| method |\x0a\x09\x0a\x09method := anAnnouncement method.\x0a\x09\x0a\x09self items detect: [ :each | each = method selector ] ifNone: [ ^ self ].\x0a\x0a    self selectedItem ifNotNil: [\x0a      \x09(method methodClass = self model selectedClass and: [ method selector = self selectedItem ])\x0a  \x09\x09\x09ifTrue: [ \x0a\x09\x09\x09\x09self selectedItem: nil; \x0a\x09\x09\x09\x09selectItem: nil ] ].\x0a\x0a    self setItemsForSelectedProtocol.\x0a\x09self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["method", "detect:ifNone:", "=", "selector", "items", "ifNotNil:", "ifTrue:", "selectedItem:", "selectItem:", "and:", "selectedItem", "selectedClass", "model", "methodClass", "setItemsForSelectedProtocol", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["method", "detect:ifNone:", "items", "=", "selector", "ifNotNil:", "selectedItem", "ifTrue:", "and:", "methodClass", "selectedClass", "model", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2708,7 +2708,7 @@ $3=_st($2)._activateItem_(selector); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{anAnnouncement:anAnnouncement,selector:selector,method:method},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onMethodSelected: anAnnouncement\x0a\x09| selector method |\x0a\x09\x0a\x09method := anAnnouncement item.\x0a\x09\x0a\x09selector := method isCompiledMethod \x0a\x09\x09ifTrue: [ method selector ]\x0a\x09\x09ifFalse: [ nil ].\x0a\x09\x09\x0a\x09self \x0a\x09\x09selectedItem: selector;\x0a\x09\x09activateItem: selector", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["item", "ifTrue:ifFalse:", "selector", "isCompiledMethod", "selectedItem:", "activateItem:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["item", "ifTrue:ifFalse:", "isCompiledMethod", "selector", "selectedItem:", "activateItem:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2748,7 +2748,7 @@ self._focus(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onProtocolAdded:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onProtocolAdded: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement theClass ifFalse: [ ^ self ].\x0a\x09\x0a\x09self setItemsForSelectedProtocol.\x0a    self refresh.\x0a\x09self focus", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:", "=", "theClass", "selectedClass", "model", "setItemsForSelectedProtocol", "refresh", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:", "=", "selectedClass", "model", "theClass", "setItemsForSelectedProtocol", "refresh", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2772,7 +2772,7 @@ self._focus(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onProtocolRemoved:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onProtocolRemoved: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement theClass ifFalse: [ ^ self ].\x0a\x09\x0a\x09self setItemsForSelectedProtocol.\x0a    self refresh.\x0a\x09self focus", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:", "=", "theClass", "selectedClass", "model", "setItemsForSelectedProtocol", "refresh", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:", "=", "selectedClass", "model", "theClass", "setItemsForSelectedProtocol", "refresh", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2828,13 +2828,13 @@ $2=acc; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($2)._addAll_(_st(each)._selectors()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3=_st($2)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"overrideSelectors",{},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "overrideSelectors\x0a\x09^ self selectorsCache \x0a    \x09at: 'override'\x0a        ifAbsentPut: [ \x0a        \x09self model selectedClass allSuperclasses\x0a\x09\x09\x09\x09inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["at:ifAbsentPut:", "inject:into:", "new", "addAll:", "selectors", "yourself", "allSuperclasses", "selectedClass", "model", "selectorsCache"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["at:ifAbsentPut:", "selectorsCache", "inject:into:", "allSuperclasses", "selectedClass", "model", "new", "addAll:", "selectors", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2856,13 +2856,13 @@ $2=acc; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($2)._addAll_(_st(each)._selectors()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3=_st($2)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"overridenSelectors",{},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "overridenSelectors\x0a\x09^ self selectorsCache \x0a    \x09at: 'overriden'\x0a        ifAbsentPut: [ \x0a        \x09self model selectedClass allSubclasses\x0a\x09\x09\x09\x09inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["at:ifAbsentPut:", "inject:into:", "new", "addAll:", "selectors", "yourself", "allSubclasses", "selectedClass", "model", "selectorsCache"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["at:ifAbsentPut:", "selectorsCache", "inject:into:", "allSubclasses", "selectedClass", "model", "new", "addAll:", "selectors", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2884,13 +2884,13 @@ _st($2)._class_("class_side"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3=_st($2)._with_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.HLToolListWidget.fn.prototype._renderContentOn_.apply(_st(self), [html]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderContentOn: html\x0a\x09self model showInstance\x0a    \x09ifFalse: [ html div \x0a        \x09class: 'class_side'; \x0a            with: [ super renderContentOn: html ] ]\x0a      \x09ifTrue: [ super renderContentOn: html ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:ifTrue:", "class:", "div", "with:", "renderContentOn:", "showInstance", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:ifTrue:", "showInstance", "model", "class:", "div", "with:", "renderContentOn:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2964,12 +2964,12 @@ var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(_st(self._methodsInProtocol_(aString))._collect_((function(each){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(each)._selector(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})))._sorted(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._sorted(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"selectorsInProtocol:",{aString:aString},smalltalk.HLMethodsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "selectorsInProtocol: aString\x0a\x09^ ((self methodsInProtocol: aString)\x0a    \x09collect: [ :each | each selector ]) sorted", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["sorted", "collect:", "selector", "methodsInProtocol:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["sorted", "collect:", "methodsInProtocol:", "selector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLMethodsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3082,7 +3082,7 @@ _st(_st(self._model())._announcer())._announce_(_st($HLClassesListFocus())._new( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"focusClassesListWidget",{},smalltalk.HLPackagesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "focusClassesListWidget\x0a\x09self model announcer announce: HLClassesListFocus new", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["announce:", "new", "announcer", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["announce:", "announcer", "model", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["HLClassesListFocus"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLPackagesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3098,13 +3098,13 @@ var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 self["@items"]=_st(_st(self._model())._packages())._sort_((function(a,b){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return _st(_st(a)._name()).__lt(_st(b)._name()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=self["@items"]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"initializeItems",{},smalltalk.HLPackagesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "initializeItems\x0a\x09^ items := self model packages \x0a\x09\x09sort: [ :a :b | a name < b name ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["sort:", "<", "name", "packages", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["sort:", "packages", "model", "<", "name"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLPackagesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3204,7 +3204,7 @@ $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{anAnnouncement:anAnnouncement},smalltalk.HLPackagesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onClassAdded: anAnnouncement\x0a\x09\x22Amber doesn't have yet a global organizer for packages\x22\x0a\x09\x0a\x09(self items includes: anAnnouncement theClass package) ifFalse: [ \x0a\x09\x09self \x0a\x09\x09\x09initializeItems;\x0a\x09\x09\x09refresh ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:", "initializeItems", "refresh", "includes:", "package", "theClass", "items"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:", "includes:", "items", "package", "theClass", "initializeItems", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLPackagesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3230,7 +3230,7 @@ $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onPackageSelected:",{anAnnouncement:anAnnouncement,package_:package_},smalltalk.HLPackagesListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onPackageSelected: anAnnouncement\x0a\x09| package |\x0a\x09\x0a\x09package := anAnnouncement item.\x0a\x09\x0a\x09self selectedItem: package.\x0a\x09self hasFocus ifFalse: [\x0a\x09\x09self\x0a\x09\x09\x09activateItem: package;\x0a\x09\x09\x09focus ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["item", "selectedItem:", "ifFalse:", "activateItem:", "focus", "hasFocus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["item", "selectedItem:", "ifFalse:", "hasFocus", "activateItem:", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLPackagesListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3470,7 +3470,7 @@ self._refresh(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onProtocolRemoved:",{anAnnouncement:anAnnouncement,class_:class_,protocol:protocol},smalltalk.HLProtocolsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onProtocolRemoved: anAnnouncement\x0a\x09| class protocol |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09protocol := anAnnouncement protocol.\x0a\x09\x0a\x09class = self model selectedClass ifFalse: [ ^ self ].\x0a    \x0a    self model selectedProtocol = protocol \x0a    \x09ifTrue: [ \x0a\x09\x09\x09self \x0a\x09\x09\x09\x09selectedItem: nil;\x0a\x09\x09\x09\x09selectItem: nil ].\x0a        \x0a    self setItemsForSelectedClass.\x0a    self refresh", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["theClass", "protocol", "ifFalse:", "=", "selectedClass", "model", "ifTrue:", "selectedItem:", "selectItem:", "selectedProtocol", "setItemsForSelectedClass", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["theClass", "protocol", "ifFalse:", "=", "selectedClass", "model", "ifTrue:", "selectedProtocol", "selectedItem:", "selectItem:", "setItemsForSelectedClass", "refresh"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLProtocolsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3503,7 +3503,7 @@ $5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"onProtocolSelected:",{anAnnouncement:anAnnouncement,protocol:protocol},smalltalk.HLProtocolsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anAnnouncement"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "onProtocolSelected: anAnnouncement\x0a\x09| protocol |\x0a\x09\x0a\x09protocol := anAnnouncement item.\x0a\x09\x0a\x09self selectedItem: protocol.\x0a\x09protocol ifNil: [ ^ self ].\x0a    \x0a\x09self hasFocus ifFalse: [\x0a\x09\x09self \x0a\x09\x09\x09activateItem: protocol;\x0a\x09\x09\x09focus ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["item", "selectedItem:", "ifNil:", "ifFalse:", "activateItem:", "focus", "hasFocus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["item", "selectedItem:", "ifNil:", "ifFalse:", "hasFocus", "activateItem:", "focus"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLProtocolsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3541,13 +3541,13 @@ _st($2)._class_("class_side"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3=_st($2)._with_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.HLToolListWidget.fn.prototype._renderContentOn_.apply(_st(self), [html]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLProtocolsListWidget)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["html"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "renderContentOn: html\x0a\x09self model showInstance\x0a    \x09ifFalse: [ html div \x0a        \x09class: 'class_side'; \x0a            with: [ super renderContentOn: html ] ]\x0a      \x09ifTrue: [ super renderContentOn: html ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifFalse:ifTrue:", "class:", "div", "with:", "renderContentOn:", "showInstance", "model"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifFalse:ifTrue:", "showInstance", "model", "class:", "div", "with:", "renderContentOn:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLProtocolsListWidget); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3650,12 +3650,12 @@ $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=_st(self._classesCache())._at_ifAbsentPut_(_st(aClass)._name(),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self._newCacheFor_(aClass); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, function($ctx1) {$ctx1.fill(self,"cacheFor:",{aClass:aClass},smalltalk.HLSelectorsCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "cacheFor: aClass\x0a\x09aClass ifNil: [ ^ nil ].\x0a    \x0a\x09^ self classesCache\x0a    \x09at: aClass name\x0a        ifAbsentPut: [ self newCacheFor: aClass ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifNil:", "at:ifAbsentPut:", "name", "newCacheFor:", "classesCache"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifNil:", "at:ifAbsentPut:", "classesCache", "name", "newCacheFor:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLSelectorsCache); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3713,7 +3713,7 @@ _st(self._cacheFor_(_st(aMethod)._methodClass()))._invalidateSelector_(_st(aMeth 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"invalidateCacheFor:",{aMethod:aMethod},smalltalk.HLSelectorsCache)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aMethod"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "invalidateCacheFor: aMethod\x0a\x09(self cacheFor: aMethod methodClass)\x0a    \x09invalidateSelector: aMethod selector", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["invalidateSelector:", "selector", "cacheFor:", "methodClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["invalidateSelector:", "cacheFor:", "methodClass", "selector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLSelectorsCache); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3779,8 +3779,8 @@ selector: "observeSystem", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'actions', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $MethodAdded(){return smalltalk.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $MethodAdded(){return smalltalk.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 function $MethodRemoved(){return smalltalk.MethodRemoved||(typeof MethodRemoved=="undefined"?nil:MethodRemoved)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var $1,$2; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3791,7 +3791,7 @@ return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},smalltalk.HLSe 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 source: "observeSystem\x0a\x09SystemAnnouncer current\x0a\x09\x09on: MethodAdded\x0a\x09\x09send: #onMethodAdded:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: MethodRemoved\x0a        send: #onMethodRemoved:\x0a\x09\x09to: self", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 messageSends: ["on:send:to:", "current"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["MethodAdded", "SystemAnnouncer", "MethodRemoved"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["SystemAnnouncer", "MethodAdded", "MethodRemoved"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.HLSelectorsCache); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 |