|  | @@ -1,23 +1,5 @@
 | 
	
		
			
				|  |  |  smalltalk.addPackage('Helios-Browser');
 | 
	
		
			
				|  |  | -smalltalk.addClass('HLBrowser', smalltalk.HLWidget, ['model', 'packagesListWidget', 'classesListWidget', 'protocolsListWidget', 'methodsListWidget', 'sourceWidget'], 'Helios-Browser');
 | 
	
		
			
				|  |  | -smalltalk.addMethod(
 | 
	
		
			
				|  |  | -smalltalk.method({
 | 
	
		
			
				|  |  | -selector: "announcer",
 | 
	
		
			
				|  |  | -category: 'accessing',
 | 
	
		
			
				|  |  | -fn: function (){
 | 
	
		
			
				|  |  | -var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -var $1;
 | 
	
		
			
				|  |  | -$1=_st(_st(self)._model())._announcer();
 | 
	
		
			
				|  |  | -return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"announcer",{},smalltalk.HLBrowser)})},
 | 
	
		
			
				|  |  | -args: [],
 | 
	
		
			
				|  |  | -source: "announcer\x0a\x09^ self model announcer",
 | 
	
		
			
				|  |  | -messageSends: ["announcer", "model"],
 | 
	
		
			
				|  |  | -referencedClasses: []
 | 
	
		
			
				|  |  | -}),
 | 
	
		
			
				|  |  | -smalltalk.HLBrowser);
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | +smalltalk.addClass('HLBrowser', smalltalk.HLWidget, ['model', 'packagesListWidget', 'classesListWidget', 'protocolsListWidget', 'methodsListWidget', 'sourceWidget', 'bottomDiv'], 'Helios-Browser');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "canHaveFocus",
 | 
	
	
		
			
				|  | @@ -359,6 +341,25 @@ smalltalk.HLBrowser.klass);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addClass('HLBrowserListWidget', smalltalk.HLNavigationListWidget, ['model'], 'Helios-Browser');
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "activateListItem:",
 | 
	
		
			
				|  |  | +category: 'actions',
 | 
	
		
			
				|  |  | +fn: function (anItem){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(_st(self)._model())._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return smalltalk.HLNavigationListWidget.fn.prototype._activateListItem_.apply(_st(self), [anItem]);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"activateListItem:",{anItem:anItem},smalltalk.HLBrowserListWidget)})},
 | 
	
		
			
				|  |  | +args: ["anItem"],
 | 
	
		
			
				|  |  | +source: "activateListItem: anItem\x0a\x09self model withChangesDo: [ super activateListItem: anItem ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "activateListItem:", "model"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBrowserListWidget);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "commandCategory",
 | 
	
	
		
			
				|  | @@ -845,7 +846,10 @@ fn: function (aClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1,$2;
 | 
	
		
			
				|  |  | -$1=_st(_st(aClass)._package()).__eq(_st(_st(self)._model())._selectedPackage());
 | 
	
		
			
				|  |  | +$1=_st(_st(_st(aClass)._package()).__eq(_st(_st(self)._model())._selectedPackage()))._or_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._items())._includes_(aClass);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  if(! smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  $2=self;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
	
		
			
				|  | @@ -854,8 +858,8 @@ _st(self)._setItemsForSelectedPackage();
 | 
	
		
			
				|  |  |  _st(self)._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{aClass:aClass},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  | -source: "onClassAdded: aClass\x0a\x09aClass package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "=", "selectedPackage", "model", "package", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  | +source: "onClassAdded: aClass\x0a\x09(aClass package = self model selectedPackage or: [\x0a\x09\x09self items includes: aClass ]) ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "or:", "includes:", "items", "=", "selectedPackage", "model", "package", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1037,7 +1041,6 @@ return smalltalk.withContext(function($ctx1) {
 | 
	
		
			
				|  |  |  var $1,$3,$4,$5,$6,$7,$8,$9,$10,$11,$2;
 | 
	
		
			
				|  |  |  $1=_st(html)._div();
 | 
	
		
			
				|  |  |  _st($1)._class_("btn-group");
 | 
	
		
			
				|  |  | -_st($1)._at_put_("data-toggle","buttons-radio");
 | 
	
		
			
				|  |  |  $2=_st($1)._with_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  $3=_st(html)._button();
 | 
	
	
		
			
				|  | @@ -1088,8 +1091,8 @@ return $11;
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  | -source: "renderButtonsOn: html\x0a\x09html div \x0a        class: 'btn-group';\x0a\x09\x09at: 'data-toggle' put: 'buttons-radio';\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\x09\x09html button\x0a  \x09\x09\x09\x09class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showComment ifTrue: [ \x0a                    \x09str nextPutAll: ' active' ] ]);\x0a  \x09\x09\x09\x09with: 'Doc';\x0a\x09\x09\x09\x09onClick: [ self showComment: true ] ]",
 | 
	
		
			
				|  |  | -messageSends: ["class:", "div", "at:put:", "with:", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "button", "onClick:", "showInstance:", "showClass", "showComment", "showComment:"],
 | 
	
		
			
				|  |  | +source: "renderButtonsOn: html\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\x09\x09html button\x0a  \x09\x09\x09\x09class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showComment ifTrue: [ \x0a                    \x09str nextPutAll: ' active' ] ]);\x0a  \x09\x09\x09\x09with: 'Doc';\x0a\x09\x09\x09\x09onClick: [ self showComment: true ] ]",
 | 
	
		
			
				|  |  | +messageSends: ["class:", "div", "with:", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "button", "onClick:", "showInstance:", "showClass", "showComment", "showComment:"],
 | 
	
		
			
				|  |  |  referencedClasses: ["String"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -2878,11 +2881,14 @@ category: 'commands actions',
 | 
	
		
			
				|  |  |  fn: function (aClassName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._copyClass_to_(_st(_st(self)._selectedClass())._theNonMetaClass(),aClassName);
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._copyClass_to_(_st(_st(self)._selectedClass())._theNonMetaClass(),aClassName);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"copyClassTo:",{aClassName:aClassName},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aClassName"],
 | 
	
		
			
				|  |  | -source: "copyClassTo: aClassName\x0a\x09self environment \x0a\x09\x09copyClass: self selectedClass theNonMetaClass\x0a\x09\x09to: aClassName",
 | 
	
		
			
				|  |  | -messageSends: ["copyClass:to:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  | +source: "copyClassTo: aClassName\x0a\x09self withChangesDo: [ \x0a\x09\x09self environment \x0a\x09\x09\x09copyClass: self selectedClass theNonMetaClass\x0a\x09\x09\x09to: aClassName ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "copyClass:to:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3052,11 +3058,14 @@ category: 'commands actions',
 | 
	
		
			
				|  |  |  fn: function (aPackageName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._moveClass_toPackage_(_st(_st(self)._selectedClass())._theNonMetaClass(),aPackageName);
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._moveClass_toPackage_(_st(_st(self)._selectedClass())._theNonMetaClass(),aPackageName);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"moveClassToPackage:",{aPackageName:aPackageName},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aPackageName"],
 | 
	
		
			
				|  |  | -source: "moveClassToPackage: aPackageName\x0a\x09self environment \x0a\x09\x09moveClass: self selectedClass theNonMetaClass\x0a\x09\x09toPackage: aPackageName",
 | 
	
		
			
				|  |  | -messageSends: ["moveClass:toPackage:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  | +source: "moveClassToPackage: aPackageName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09moveClass: self selectedClass theNonMetaClass\x0a\x09\x09\x09toPackage: aPackageName ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "moveClass:toPackage:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3068,11 +3077,14 @@ category: 'commands actions',
 | 
	
		
			
				|  |  |  fn: function (aClassName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._moveMethod_toClass_(_st(self)._selectedMethod(),aClassName);
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._moveMethod_toClass_(_st(self)._selectedMethod(),aClassName);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"moveMethodToClass:",{aClassName:aClassName},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aClassName"],
 | 
	
		
			
				|  |  | -source: "moveMethodToClass: aClassName\x0a\x09self environment \x0a\x09\x09moveMethod: self selectedMethod \x0a\x09\x09toClass: aClassName",
 | 
	
		
			
				|  |  | -messageSends: ["moveMethod:toClass:", "selectedMethod", "environment"],
 | 
	
		
			
				|  |  | +source: "moveMethodToClass: aClassName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09moveMethod: self selectedMethod \x0a\x09\x09\x09toClass: aClassName ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "moveMethod:toClass:", "selectedMethod", "environment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3084,11 +3096,14 @@ category: 'commands actions',
 | 
	
		
			
				|  |  |  fn: function (aProtocol){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._moveMethod_toProtocol_(_st(self)._selectedMethod(),aProtocol);
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._moveMethod_toProtocol_(_st(self)._selectedMethod(),aProtocol);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"moveMethodToProtocol:",{aProtocol:aProtocol},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aProtocol"],
 | 
	
		
			
				|  |  | -source: "moveMethodToProtocol: aProtocol\x0a\x09self environment moveMethod: self selectedMethod toProtocol: aProtocol",
 | 
	
		
			
				|  |  | -messageSends: ["moveMethod:toProtocol:", "selectedMethod", "environment"],
 | 
	
		
			
				|  |  | +source: "moveMethodToProtocol: aProtocol\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09moveMethod: self selectedMethod \x0a\x09\x09\x09toProtocol: aProtocol ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "moveMethod:toProtocol:", "selectedMethod", "environment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3101,13 +3116,17 @@ fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var class_;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  class_=_st(_st(self)._environment())._classNamed_(aString);
 | 
	
		
			
				|  |  | +class_;
 | 
	
		
			
				|  |  |  _st(self)._selectedPackage_(_st(class_)._package());
 | 
	
		
			
				|  |  | -_st(self)._selectedClass_(class_);
 | 
	
		
			
				|  |  | +return _st(self)._selectedClass_(class_);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"openClassNamed:",{aString:aString,class_:class_},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  | -source: "openClassNamed: aString\x0a\x09| class |\x0a\x09\x0a\x09class := self environment classNamed: aString.\x0a\x09self selectedPackage: class package.\x0a\x09self selectedClass: class",
 | 
	
		
			
				|  |  | -messageSends: ["classNamed:", "environment", "selectedPackage:", "package", "selectedClass:"],
 | 
	
		
			
				|  |  | +source: "openClassNamed: aString\x0a\x09| class |\x0a\x09\x0a\x09self withChangesDo: [\x0a\x09\x09class := self environment classNamed: aString.\x0a\x09\x09self selectedPackage: class package.\x0a\x09\x09self selectedClass: class ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "classNamed:", "environment", "selectedPackage:", "package", "selectedClass:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3138,14 +3157,17 @@ fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._manager())._confirm_(_st("Do you REALLY want to remove class ").__comma(_st(_st(self)._selectedClass())._name()));
 | 
	
		
			
				|  |  |  if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._removeClass_(_st(self)._selectedClass());
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._removeClass_(_st(self)._selectedClass());
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"removeClass",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  | -source: "removeClass\x0a\x09(self manager confirm: 'Do you REALLY want to remove class ', self selectedClass name)\x0a\x09\x09ifTrue: [ self environment removeClass: self selectedClass ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "removeClass:", "selectedClass", "environment", "confirm:", ",", "name", "manager"],
 | 
	
		
			
				|  |  | +source: "removeClass\x0a\x09self withChangesDo: [\x0a\x09\x09(self manager confirm: 'Do you REALLY want to remove class ', self selectedClass name)\x0a\x09\x09\x09ifTrue: [ self environment removeClass: self selectedClass ] ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "ifTrue:", "removeClass:", "selectedClass", "environment", "confirm:", ",", "name", "manager"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3158,14 +3180,17 @@ fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._manager())._confirm_(_st(_st(_st("Do you REALLY want to remove method ").__comma(_st(_st(_st(self)._selectedMethod())._methodClass())._name())).__comma(" >> #")).__comma(_st(_st(self)._selectedMethod())._selector()));
 | 
	
		
			
				|  |  |  if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._removeMethod_(_st(self)._selectedMethod());
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._removeMethod_(_st(self)._selectedMethod());
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"removeMethod",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  | -source: "removeMethod\x0a\x09(self manager confirm: 'Do you REALLY want to remove method ', self selectedMethod methodClass name,' >> #', self selectedMethod selector)\x0a\x09\x09ifTrue: [ self environment removeMethod: self selectedMethod ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "removeMethod:", "selectedMethod", "environment", "confirm:", ",", "selector", "name", "methodClass", "manager"],
 | 
	
		
			
				|  |  | +source: "removeMethod\x0a\x09self withChangesDo: [\x0a\x09\x09(self manager confirm: 'Do you REALLY want to remove method ', self selectedMethod methodClass name,' >> #', self selectedMethod selector)\x0a\x09\x09\x09ifTrue: [ self environment removeMethod: self selectedMethod ] ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "ifTrue:", "removeMethod:", "selectedMethod", "environment", "confirm:", ",", "selector", "name", "methodClass", "manager"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3178,14 +3203,17 @@ fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._manager())._confirm_(_st("Do you REALLY want to remove protocol ").__comma(_st(self)._selectedProtocol()));
 | 
	
		
			
				|  |  |  if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._removeProtocol_from_(_st(self)._selectedProtocol(),_st(self)._selectedClass());
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._removeProtocol_from_(_st(self)._selectedProtocol(),_st(self)._selectedClass());
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"removeProtocol",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  | -source: "removeProtocol\x0a\x09(self manager confirm: 'Do you REALLY want to remove protocol ', self selectedProtocol)\x0a\x09\x09ifTrue: [ self environment \x0a\x09\x09\x09removeProtocol: self selectedProtocol \x0a\x09\x09\x09from: self selectedClass ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "removeProtocol:from:", "selectedProtocol", "selectedClass", "environment", "confirm:", ",", "manager"],
 | 
	
		
			
				|  |  | +source: "removeProtocol\x0a\x09self withChangesDo: [\x0a\x09\x09(self manager confirm: 'Do you REALLY want to remove protocol ', self selectedProtocol)\x0a\x09\x09\x09ifTrue: [ self environment \x0a\x09\x09\x09\x09removeProtocol: self selectedProtocol \x0a\x09\x09\x09\x09from: self selectedClass ] ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "ifTrue:", "removeProtocol:from:", "selectedProtocol", "selectedClass", "environment", "confirm:", ",", "manager"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3197,11 +3225,14 @@ category: 'commands actions',
 | 
	
		
			
				|  |  |  fn: function (aClassName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._renameClass_to_(_st(_st(self)._selectedClass())._theNonMetaClass(),aClassName);
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._renameClass_to_(_st(_st(self)._selectedClass())._theNonMetaClass(),aClassName);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renameClassTo:",{aClassName:aClassName},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aClassName"],
 | 
	
		
			
				|  |  | -source: "renameClassTo: aClassName\x0a\x09self environment \x0a\x09\x09renameClass: self selectedClass theNonMetaClass\x0a\x09\x09to: aClassName",
 | 
	
		
			
				|  |  | -messageSends: ["renameClass:to:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  | +source: "renameClassTo: aClassName\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09renameClass: self selectedClass theNonMetaClass\x0a\x09\x09\x09to: aClassName ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "renameClass:to:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3213,11 +3244,14 @@ category: 'commands actions',
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -_st(_st(self)._environment())._renameProtocol_to_in_(_st(self)._selectedProtocol(),aString,_st(self)._selectedClass());
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(_st(self)._environment())._renameProtocol_to_in_(_st(self)._selectedProtocol(),aString,_st(self)._selectedClass());
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renameProtocolTo:",{aString:aString},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  | -source: "renameProtocolTo: aString\x0a\x09self environment \x0a\x09\x09renameProtocol: self selectedProtocol\x0a\x09\x09to: aString\x0a\x09\x09in: self selectedClass",
 | 
	
		
			
				|  |  | -messageSends: ["renameProtocol:to:in:", "selectedProtocol", "selectedClass", "environment"],
 | 
	
		
			
				|  |  | +source: "renameProtocolTo: aString\x0a\x09self withChangesDo: [\x0a\x09\x09self environment \x0a\x09\x09\x09renameProtocol: self selectedProtocol\x0a\x09\x09\x09to: aString\x0a\x09\x09\x09in: self selectedClass ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "renameProtocol:to:in:", "selectedProtocol", "selectedClass", "environment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3228,8 +3262,10 @@ selector: "save:",
 | 
	
		
			
				|  |  |  category: 'actions',
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $HLSourceCodeSaved(){return smalltalk.HLSourceCodeSaved||(typeof HLSourceCodeSaved=="undefined"?nil:HLSourceCodeSaved)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1;
 | 
	
		
			
				|  |  | +_st(_st(self)._announcer())._announce_(_st($HLSourceCodeSaved())._new());
 | 
	
		
			
				|  |  |  $1=_st(self)._shouldCompileClassDefinition_(aString);
 | 
	
		
			
				|  |  |  if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  _st(self)._compileClassDefinition_(aString);
 | 
	
	
		
			
				|  | @@ -3238,9 +3274,9 @@ _st(self)._compileMethod_(aString);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"save:",{aString:aString},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  | -source: "save: aString\x0a\x09(self shouldCompileClassDefinition: aString)\x0a\x09\x09ifTrue: [ self compileClassDefinition: aString ]\x0a\x09\x09ifFalse: [ self compileMethod: aString ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:ifFalse:", "compileClassDefinition:", "compileMethod:", "shouldCompileClassDefinition:"],
 | 
	
		
			
				|  |  | -referencedClasses: []
 | 
	
		
			
				|  |  | +source: "save: aString\x0a\x09self announcer announce: HLSourceCodeSaved new.\x0a\x09\x0a\x09(self shouldCompileClassDefinition: aString)\x0a\x09\x09ifTrue: [ self compileClassDefinition: aString ]\x0a\x09\x09ifFalse: [ self compileMethod: aString ]",
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "new", "announcer", "ifTrue:ifFalse:", "compileClassDefinition:", "compileMethod:", "shouldCompileClassDefinition:"],
 | 
	
		
			
				|  |  | +referencedClasses: ["HLSourceCodeSaved"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -3288,15 +3324,17 @@ var self=this;
 | 
	
		
			
				|  |  |  function $HLClassSelected(){return smalltalk.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1,$2,$3,$4,$5;
 | 
	
		
			
				|  |  | -$1=_st(self["@selectedClass"]).__eq(aClass);
 | 
	
		
			
				|  |  | -if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  | -$2=aClass;
 | 
	
		
			
				|  |  | -if(($receiver = $2) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | -$3=self;
 | 
	
		
			
				|  |  | -return $3;
 | 
	
		
			
				|  |  | +$1=aClass;
 | 
	
		
			
				|  |  | +if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | +$2=self;
 | 
	
		
			
				|  |  | +return $2;
 | 
	
		
			
				|  |  |  } else {
 | 
	
		
			
				|  |  | -$2;
 | 
	
		
			
				|  |  | +$1;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +$3=_st(self["@selectedClass"]).__eq(aClass);
 | 
	
		
			
				|  |  | +if(smalltalk.assert($3)){
 | 
	
		
			
				|  |  |  _st(self)._selectedProtocol_(nil);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  $4=aClass;
 | 
	
	
		
			
				|  | @@ -3314,11 +3352,12 @@ self["@selectedClass"];
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  _st(self)._selectedProtocol_(nil);
 | 
	
		
			
				|  |  | -_st(_st(self)._announcer())._announce_(_st($HLClassSelected())._on_(_st(self)._selectedClass()));
 | 
	
		
			
				|  |  | +return _st(_st(self)._announcer())._announce_(_st($HLClassSelected())._on_(_st(self)._selectedClass()));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"selectedClass:",{aClass:aClass},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  | -source: "selectedClass: aClass\x0a\x09selectedClass = aClass ifTrue: [ \x0a\x09\x09aClass ifNil: [ ^ self ].\x0a\x09\x09self selectedProtocol: nil ].\x0a    \x0a\x09aClass \x0a   \x09\x09ifNil: [ selectedClass := nil ]\x0a    \x09ifNotNil: [\x0a\x09\x09\x09self showInstance \x0a   \x09\x09\x09\x09ifTrue: [ selectedClass := aClass theNonMetaClass ]\x0a     \x09\x09\x09ifFalse: [ selectedClass := aClass theMetaClass ] ].\x0a\x09self selectedProtocol: nil.\x0a\x09self announcer announce: (HLClassSelected on: self selectedClass)",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "ifNil:", "selectedProtocol:", "=", "ifNil:ifNotNil:", "ifTrue:ifFalse:", "theNonMetaClass", "theMetaClass", "showInstance", "announce:", "on:", "selectedClass", "announcer"],
 | 
	
		
			
				|  |  | +source: "selectedClass: aClass\x0a\x09aClass ifNil: [ ^ self ].\x0a\x09\x0a\x09self withChangesDo: [\x0a\x09\x09selectedClass = aClass ifTrue: [ \x0a\x09\x09\x09self selectedProtocol: nil ].\x0a    \x0a\x09\x09aClass \x0a   \x09\x09\x09ifNil: [ selectedClass := nil ]\x0a    \x09\x09ifNotNil: [\x0a\x09\x09\x09\x09self showInstance \x0a   \x09\x09\x09\x09\x09ifTrue: [ selectedClass := aClass theNonMetaClass ]\x0a     \x09\x09\x09\x09ifFalse: [ selectedClass := aClass theMetaClass ] ].\x0a\x09\x09self selectedProtocol: nil.\x0a\x09\x09self announcer announce: (HLClassSelected on: self selectedClass) ]",
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "withChangesDo:", "ifTrue:", "selectedProtocol:", "=", "ifNil:ifNotNil:", "ifTrue:ifFalse:", "theNonMetaClass", "theMetaClass", "showInstance", "announce:", "on:", "selectedClass", "announcer"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLClassSelected"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3357,30 +3396,28 @@ fn: function (aCompiledMethod){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $HLMethodSelected(){return smalltalk.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | -var $1,$2,$3,$4,$5;
 | 
	
		
			
				|  |  | +var $1,$2,$3;
 | 
	
		
			
				|  |  |  $1=_st(self["@selectedSelector"]).__eq(aCompiledMethod);
 | 
	
		
			
				|  |  |  if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  $2=self;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  $3=aCompiledMethod;
 | 
	
		
			
				|  |  |  if(($receiver = $3) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  |  self["@selectedSelector"]=nil;
 | 
	
		
			
				|  |  |  self["@selectedSelector"];
 | 
	
		
			
				|  |  |  } else {
 | 
	
		
			
				|  |  | -$4=_st(self["@selectedSelector"]).__eq(_st(aCompiledMethod)._selector());
 | 
	
		
			
				|  |  | -if(smalltalk.assert($4)){
 | 
	
		
			
				|  |  | -$5=self;
 | 
	
		
			
				|  |  | -return $5;
 | 
	
		
			
				|  |  | -};
 | 
	
		
			
				|  |  |  self["@selectedSelector"]=_st(aCompiledMethod)._selector();
 | 
	
		
			
				|  |  |  self["@selectedSelector"];
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -_st(_st(self)._announcer())._announce_(_st($HLMethodSelected())._on_(aCompiledMethod));
 | 
	
		
			
				|  |  | +return _st(_st(self)._announcer())._announce_(_st($HLMethodSelected())._on_(aCompiledMethod));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"selectedMethod:",{aCompiledMethod:aCompiledMethod},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aCompiledMethod"],
 | 
	
		
			
				|  |  | -source: "selectedMethod: aCompiledMethod\x0a\x09selectedSelector = aCompiledMethod ifTrue: [ ^ self ].\x0a    \x0a    aCompiledMethod\x0a    \x09ifNil: [ selectedSelector := nil ]\x0a      \x09ifNotNil: [\x0a\x09\x09\x09selectedSelector = aCompiledMethod selector ifTrue: [ ^ self ].\x0a\x09\x09\x09selectedSelector := aCompiledMethod selector ].\x0a\x0a    self announcer announce: (HLMethodSelected on: aCompiledMethod)",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "=", "ifNil:ifNotNil:", "selector", "announce:", "on:", "announcer"],
 | 
	
		
			
				|  |  | +source: "selectedMethod: aCompiledMethod\x0a\x09selectedSelector = aCompiledMethod ifTrue: [ ^ self ].\x0a    \x0a    self withChangesDo: [\x0a\x09\x09aCompiledMethod\x0a    \x09\x09ifNil: [ selectedSelector := nil ]\x0a      \x09\x09ifNotNil: [\x0a\x09\x09\x09\x09selectedSelector := aCompiledMethod selector ].\x0a\x0a\x09\x09self announcer announce: (HLMethodSelected on: aCompiledMethod) ]",
 | 
	
		
			
				|  |  | +messageSends: ["ifTrue:", "=", "withChangesDo:", "ifNil:ifNotNil:", "selector", "announce:", "on:", "announcer"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLMethodSelected"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3417,13 +3454,17 @@ if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  $2=self;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  self["@selectedPackage"]=aPackage;
 | 
	
		
			
				|  |  | +self["@selectedPackage"];
 | 
	
		
			
				|  |  |  _st(self)._selectedClass_(nil);
 | 
	
		
			
				|  |  | -_st(_st(self)._announcer())._announce_(_st($HLPackageSelected())._on_(aPackage));
 | 
	
		
			
				|  |  | +return _st(_st(self)._announcer())._announce_(_st($HLPackageSelected())._on_(aPackage));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"selectedPackage:",{aPackage:aPackage},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aPackage"],
 | 
	
		
			
				|  |  | -source: "selectedPackage: aPackage\x0a\x09selectedPackage = aPackage ifTrue: [ ^ self ].\x0a    \x0a\x09selectedPackage := aPackage.\x0a\x09self selectedClass: nil.\x0a    self announcer announce: (HLPackageSelected on: aPackage)",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "=", "selectedClass:", "announce:", "on:", "announcer"],
 | 
	
		
			
				|  |  | +source: "selectedPackage: aPackage\x0a\x09selectedPackage = aPackage ifTrue: [ ^ self ].\x0a    \x0a\x09self withChangesDo: [\x0a\x09\x09selectedPackage := aPackage.\x0a\x09\x09self selectedClass: nil.\x0a\x09\x09self announcer announce: (HLPackageSelected on: aPackage) ]",
 | 
	
		
			
				|  |  | +messageSends: ["ifTrue:", "=", "withChangesDo:", "selectedClass:", "announce:", "on:", "announcer"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLPackageSelected"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3460,13 +3501,17 @@ if(smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  $2=self;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  self["@selectedProtocol"]=aString;
 | 
	
		
			
				|  |  | +self["@selectedProtocol"];
 | 
	
		
			
				|  |  |  _st(self)._selectedMethod_(nil);
 | 
	
		
			
				|  |  | -_st(_st(self)._announcer())._announce_(_st($HLProtocolSelected())._on_(aString));
 | 
	
		
			
				|  |  | +return _st(_st(self)._announcer())._announce_(_st($HLProtocolSelected())._on_(aString));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"selectedProtocol:",{aString:aString},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  | -source: "selectedProtocol: aString\x0a\x09selectedProtocol = aString ifTrue: [ ^ self ].\x0a    \x0a\x09selectedProtocol := aString.\x0a    self selectedMethod: nil.\x0a    self announcer announce: (HLProtocolSelected on: aString)",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "=", "selectedMethod:", "announce:", "on:", "announcer"],
 | 
	
		
			
				|  |  | +source: "selectedProtocol: aString\x0a\x09selectedProtocol = aString ifTrue: [ ^ self ].\x0a\x0a\x09self withChangesDo: [\x0a\x09\x09selectedProtocol := aString.\x0a\x09\x09self selectedMethod: nil.\x0a\x09\x09self announcer announce: (HLProtocolSelected on: aString) ]",
 | 
	
		
			
				|  |  | +messageSends: ["ifTrue:", "=", "withChangesDo:", "selectedMethod:", "announce:", "on:", "announcer"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLProtocolSelected"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3523,12 +3568,16 @@ fn: function (aBoolean){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  function $HLShowCommentToggled(){return smalltalk.HLShowCommentToggled||(typeof HLShowCommentToggled=="undefined"?nil:HLShowCommentToggled)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  self["@showComment"]=aBoolean;
 | 
	
		
			
				|  |  | -_st(_st(self)._announcer())._announce_(_st($HLShowCommentToggled())._new());
 | 
	
		
			
				|  |  | +self["@showComment"];
 | 
	
		
			
				|  |  | +return _st(_st(self)._announcer())._announce_(_st($HLShowCommentToggled())._new());
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"showComment:",{aBoolean:aBoolean},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aBoolean"],
 | 
	
		
			
				|  |  | -source: "showComment: aBoolean\x0a\x09showComment := aBoolean.\x0a\x0a    self announcer announce: HLShowCommentToggled new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +source: "showComment: aBoolean\x0a\x09self withChangesDo: [\x0a\x09\x09showComment := aBoolean.\x0a\x09\x09self announcer announce: HLShowCommentToggled new ]",
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "announce:", "new", "announcer"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLShowCommentToggled"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3565,8 +3614,12 @@ var self=this;
 | 
	
		
			
				|  |  |  function $HLShowInstanceToggled(){return smalltalk.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1,$2,$4,$3;
 | 
	
		
			
				|  |  | +_st(self)._withChangesDo_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  self["@showInstance"]=aBoolean;
 | 
	
		
			
				|  |  | +self["@showInstance"];
 | 
	
		
			
				|  |  |  self["@showComment"]=false;
 | 
	
		
			
				|  |  | +self["@showComment"];
 | 
	
		
			
				|  |  |  $1=_st(self)._selectedClass();
 | 
	
		
			
				|  |  |  if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  |  $1;
 | 
	
	
		
			
				|  | @@ -3580,11 +3633,12 @@ $3=_st(_st(self)._selectedClass())._theMetaClass();
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  _st($2)._selectedClass_($3);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -_st(_st(self)._announcer())._announce_(_st($HLShowInstanceToggled())._new());
 | 
	
		
			
				|  |  | +return _st(_st(self)._announcer())._announce_(_st($HLShowInstanceToggled())._new());
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"showInstance:",{aBoolean:aBoolean},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aBoolean"],
 | 
	
		
			
				|  |  | -source: "showInstance: aBoolean\x0a\x09showInstance := aBoolean.\x0a\x09showComment := false.\x0a\x0a    self selectedClass ifNotNil: [\x0a    \x09self selectedClass: (aBoolean\x0a    \x09\x09ifTrue: [self selectedClass theNonMetaClass ]\x0a    \x09  \x09ifFalse: [ self selectedClass theMetaClass ]) ].\x0a    \x0a    self announcer announce: HLShowInstanceToggled new",
 | 
	
		
			
				|  |  | -messageSends: ["ifNotNil:", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "selectedClass", "theMetaClass", "announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +source: "showInstance: aBoolean\x0a\x0a\x09self withChangesDo: [\x0a\x09\x09showInstance := aBoolean.\x0a\x09\x09showComment := false.\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"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLShowInstanceToggled"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -3605,6 +3659,30 @@ referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "withChangesDo:",
 | 
	
		
			
				|  |  | +category: 'error handling',
 | 
	
		
			
				|  |  | +fn: function (aBlock){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +function $HLChangeForbidden(){return smalltalk.HLChangeForbidden||(typeof HLChangeForbidden=="undefined"?nil:HLChangeForbidden)}
 | 
	
		
			
				|  |  | +function $HLAboutToChange(){return smalltalk.HLAboutToChange||(typeof HLAboutToChange=="undefined"?nil:HLAboutToChange)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +_st(_st(self)._announcer())._announce_(_st($HLAboutToChange())._new());
 | 
	
		
			
				|  |  | +return _st(aBlock)._value();
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_($HLChangeForbidden(),(function(ex){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1)})}));
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"withChangesDo:",{aBlock:aBlock},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  | +args: ["aBlock"],
 | 
	
		
			
				|  |  | +source: "withChangesDo: aBlock\x0a\x09[ \x0a\x09\x09self announcer announce: HLAboutToChange new.\x0a\x09\x09aBlock value\x0a\x09]\x0a\x09\x09on: HLChangeForbidden \x0a\x09\x09do: [ :ex | ]",
 | 
	
		
			
				|  |  | +messageSends: ["on:do:", "announce:", "new", "announcer", "value"],
 | 
	
		
			
				|  |  | +referencedClasses: ["HLChangeForbidden", "HLAboutToChange"]
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBrowserModel);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "withCompileErrorHandling:",
 |