All helios files in one location

helios-niflheim.css → resources/helios-niflheim.css

@@ -4,7 +4,7 @@ body[id="helios"].niflheim {
 		  width: 100%;
 		}*/
   /*.tool_container .pane .nav-pills i.package {
-			background-image: url('package.png');
+			background-image: url('resources/package.png');
 		}*/
 }
 body[id="helios"].niflheim .btn-group > .dropdown-menu {
@@ -125,7 +125,7 @@ body[id="helios"].niflheim .welcome {
 body[id="helios"].niflheim [class^="icon-"],
 body[id="helios"].niflheim body[id="helios"][class*=" icon-"] {
   opacity: 0.68;
-  background-image: url("../../bower_components/bootstrap/img/glyphicons-halflings-white.png");
+  background-image: url("../../../bower_components/bootstrap/img/glyphicons-halflings-white.png");
 }
 body[id="helios"].niflheim .welcome h2 {
   text-align: center;

helios-niflheim.less → resources/helios-niflheim.less

@@ -152,7 +152,7 @@ body[id="helios"] {
 
 		[class^="icon-"], body[id="helios"][class*=" icon-"]{
 			opacity: 0.68;
-			background-image: url("../../bower_components/bootstrap/img/glyphicons-halflings-white.png");
+			background-image: url("../../../bower_components/bootstrap/img/glyphicons-halflings-white.png");
 		}
 
 		.welcome h2 {
@@ -186,7 +186,7 @@ body[id="helios"] {
 	
 		//todo: remove
 		/*.tool_container .pane .nav-pills i.package {
-			background-image: url('package.png');
+			background-image: url('resources/package.png');
 		}*/
 
 		.tool_container .list-label {

helios.css → resources/helios.css

@@ -443,7 +443,7 @@ body[id="helios"] .tool_container .pane .nav-pills i.package {
   background-image: url('package.png');
 }
 body[id="helios"] .tool_container .pane .nav-pills i.override {
-  background-image: url('override.png ');
+  background-image: url('resources/override.png ');
 }
 body[id="helios"] .tool_container .pane .nav-pills i.overridden {
   background-image: url('overridden.png');

helios.less → resources/helios.less

@@ -515,7 +515,7 @@ body[id="helios"] {
 		background-image: url('package.png');
 	}
 	.tool_container .pane .nav-pills i.override {
-		background-image: url('override.png ');
+		background-image: url('resources/override.png ');
 	}
 	.tool_container .pane .nav-pills i.overridden {
 		background-image: url('overridden.png');

src/Helios-Announcements.js

@@ -0,0 +1,655 @@
+define("helios/Helios-Announcements", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Announcements');
+smalltalk.packages["Helios-Announcements"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLAboutToChange', globals.Object, ['actionBlock'], 'Helios-Announcements');
+globals.HLAboutToChange.comment="I am announced whenever a change of context is about to be made, and unsaved changes could be lost.\x0a\x0aI am used within `HLModel` to handle such user actions. See `HLModel >> withChangesDo:`.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "actionBlock",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@actionBlock"];
+return $1;
+},
+args: [],
+source: "actionBlock\x0a\x09^ actionBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLAboutToChange);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "actionBlock:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@actionBlock"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "actionBlock: aBlock\x0a\x09actionBlock := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLAboutToChange);
+
+
+
+smalltalk.addClass('HLAnnouncement', globals.Object, [], 'Helios-Announcements');
+globals.HLAnnouncement.comment="I am the root of the announcement class hierarchy used in the Helios UI.";
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "heliosClass",
+protocol: 'helios',
+fn: function (){
+var self=this;
+return "announcement";
+},
+args: [],
+source: "heliosClass\x0a\x09^ 'announcement'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLAnnouncement.klass);
+
+
+smalltalk.addClass('HLCodeHandled', globals.HLAnnouncement, ['code'], 'Helios-Announcements');
+globals.HLCodeHandled.comment="I am the root class of announcements emitted by `HLCodeWidget`s";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "code",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@code"];
+return $1;
+},
+args: [],
+source: "code\x0a\x0a\x09^ code",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeHandled);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "code:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+self["@code"]=aModel;
+return self},
+args: ["aModel"],
+source: "code: aModel\x0a\x0a\x09code := aModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeHandled);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'actions',
+fn: function (aCodeModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._code_(aCodeModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aCodeModel:aCodeModel},globals.HLCodeHandled.klass)})},
+args: ["aCodeModel"],
+source: "on: aCodeModel\x0a\x0a\x09^ self new \x0a    \x09code: aCodeModel;\x0a        yourself",
+messageSends: ["code:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLCodeHandled.klass);
+
+
+smalltalk.addClass('HLDoItExecuted', globals.HLCodeHandled, [], 'Helios-Announcements');
+globals.HLDoItExecuted.comment="I am emitted by a `HLCodeWidget` after a DoIt has been executed.";
+
+
+smalltalk.addClass('HLDebuggerAnnouncement', globals.HLAnnouncement, ['context'], 'Helios-Announcements');
+globals.HLDebuggerAnnouncement.comment="I am the root class of debugger announcements, and hold onto the debugged `context`.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "context",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@context"];
+return $1;
+},
+args: [],
+source: "context\x0a\x09^ context",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerAnnouncement);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "context:",
+protocol: 'accessing',
+fn: function (aContext){
+var self=this;
+self["@context"]=aContext;
+return self},
+args: ["aContext"],
+source: "context: aContext\x0a\x09context := aContext",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerAnnouncement);
+
+
+
+smalltalk.addClass('HLDebuggerContextSelected', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+globals.HLDebuggerContextSelected.comment="I am announced when a new context is selected in a debugger, to update the user interface.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "context",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@context"];
+return $1;
+},
+args: [],
+source: "context\x0a\x09^ context",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerContextSelected);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "context:",
+protocol: 'accessing',
+fn: function (aContext){
+var self=this;
+self["@context"]=aContext;
+return self},
+args: ["aContext"],
+source: "context: aContext\x0a\x09context := aContext",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerContextSelected);
+
+
+
+smalltalk.addClass('HLDebuggerProceeded', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLDebuggerStepped', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLDebuggerWhere', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLDiveRequested', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLEditComment', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLErrorRaised', globals.HLAnnouncement, ['error'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "error",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@error"];
+return $1;
+},
+args: [],
+source: "error\x0a\x09^ error",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLErrorRaised);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "error:",
+protocol: 'accessing',
+fn: function (anError){
+var self=this;
+self["@error"]=anError;
+return self},
+args: ["anError"],
+source: "error: anError\x0a\x09error := anError",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLErrorRaised);
+
+
+
+smalltalk.addClass('HLCompileErrorRaised', globals.HLErrorRaised, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLParseErrorRaised', globals.HLErrorRaised, ['line', 'column', 'message'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "column",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@column"];
+return $1;
+},
+args: [],
+source: "column\x0a\x09^ column",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLParseErrorRaised);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "column:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+self["@column"]=anInteger;
+return self},
+args: ["anInteger"],
+source: "column: anInteger\x0a\x09column := anInteger",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLParseErrorRaised);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "line",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@line"];
+return $1;
+},
+args: [],
+source: "line\x0a\x09^ line",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLParseErrorRaised);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "line:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+self["@line"]=anInteger;
+return self},
+args: ["anInteger"],
+source: "line: anInteger\x0a\x09line := anInteger",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLParseErrorRaised);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "message",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@message"];
+return $1;
+},
+args: [],
+source: "message\x0a\x09^ message",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLParseErrorRaised);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "message:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@message"]=aString;
+return self},
+args: ["aString"],
+source: "message: aString\x0a\x09message := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLParseErrorRaised);
+
+
+
+smalltalk.addClass('HLUnknownVariableErrorRaised', globals.HLErrorRaised, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLFocusRequested', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLClassesFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLDocumentationFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLMethodsFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLPackagesFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLProtocolsFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLSourceCodeFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLInstVarAdded', globals.HLAnnouncement, ['theClass', 'variableName'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "theClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@theClass"];
+return $1;
+},
+args: [],
+source: "theClass\x0a\x09^ theClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInstVarAdded);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "theClass:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+self["@theClass"]=aClass;
+return self},
+args: ["aClass"],
+source: "theClass: aClass\x0a\x09theClass := aClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInstVarAdded);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variableName",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@variableName"];
+return $1;
+},
+args: [],
+source: "variableName\x0a\x09^ variableName",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInstVarAdded);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variableName:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@variableName"]=aString;
+return self},
+args: ["aString"],
+source: "variableName: aString\x0a\x09variableName := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInstVarAdded);
+
+
+
+smalltalk.addClass('HLItemSelected', globals.HLAnnouncement, ['item'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "item",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@item"];
+return $1;
+},
+args: [],
+source: "item\x0a\x09^ item",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLItemSelected);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "item:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@item"]=anObject;
+return self},
+args: ["anObject"],
+source: "item: anObject\x0a\x09item := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLItemSelected);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._item_(anItem);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anItem:anItem},globals.HLItemSelected.klass)})},
+args: ["anItem"],
+source: "on: anItem\x0a\x09^ self new\x0a    \x09item: anItem;\x0a        yourself",
+messageSends: ["item:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLItemSelected.klass);
+
+
+smalltalk.addClass('HLClassSelected', globals.HLItemSelected, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLInstanceVariableSelected', globals.HLItemSelected, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLMethodSelected', globals.HLItemSelected, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLPackageSelected', globals.HLItemSelected, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLProtocolSelected', globals.HLItemSelected, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLSaveSourceCode', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLSearchReferences', globals.HLAnnouncement, ['searchString'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "searchString",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@searchString"];
+return $1;
+},
+args: [],
+source: "searchString\x0a\x09^ searchString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSearchReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "searchString:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@searchString"]=aString;
+return self},
+args: ["aString"],
+source: "searchString: aString\x0a\x09searchString := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSearchReferences);
+
+
+
+smalltalk.addClass('HLShowCommentToggled', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLShowInstanceToggled', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLShowTemplate', globals.HLAnnouncement, ['template'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "template",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@template"];
+return $1;
+},
+args: [],
+source: "template\x0a\x09^ template",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLShowTemplate);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "template:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@template"]=aString;
+return self},
+args: ["aString"],
+source: "template: aString\x0a\x09template := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLShowTemplate);
+
+
+
+smalltalk.addClass('HLSourceCodeSaved', globals.HLAnnouncement, [], 'Helios-Announcements');
+
+
+smalltalk.addClass('HLTabLabelChanged', globals.HLAnnouncement, ['label', 'widget'], 'Helios-Announcements');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@label"];
+return $1;
+},
+args: [],
+source: "label\x0a\x09^ label",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabLabelChanged);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@label"]=aString;
+return self},
+args: ["aString"],
+source: "label: aString\x0a\x09label := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabLabelChanged);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "widget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@widget"];
+return $1;
+},
+args: [],
+source: "widget\x0a\x09^ widget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabLabelChanged);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "widget:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+self["@widget"]=aWidget;
+return self},
+args: ["aWidget"],
+source: "widget: aWidget\x0a\x09widget := aWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabLabelChanged);
+
+
+});

src/Helios-Announcements.st

@@ -0,0 +1,326 @@
+Smalltalk createPackage: 'Helios-Announcements'!
+Object subclass: #HLAboutToChange
+	instanceVariableNames: 'actionBlock'
+	package: 'Helios-Announcements'!
+!HLAboutToChange commentStamp!
+I am announced whenever a change of context is about to be made, and unsaved changes could be lost.
+
+I am used within `HLModel` to handle such user actions. See `HLModel >> withChangesDo:`.!
+
+!HLAboutToChange methodsFor: 'accessing'!
+
+actionBlock
+	^ actionBlock
+!
+
+actionBlock: aBlock
+	actionBlock := aBlock
+! !
+
+Object subclass: #HLAnnouncement
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+!HLAnnouncement commentStamp!
+I am the root of the announcement class hierarchy used in the Helios UI.!
+
+!HLAnnouncement class methodsFor: 'helios'!
+
+heliosClass
+	^ 'announcement'
+! !
+
+HLAnnouncement subclass: #HLCodeHandled
+	instanceVariableNames: 'code'
+	package: 'Helios-Announcements'!
+!HLCodeHandled commentStamp!
+I am the root class of announcements emitted by `HLCodeWidget`s!
+
+!HLCodeHandled methodsFor: 'accessing'!
+
+code
+
+	^ code
+!
+
+code: aModel
+
+	code := aModel
+! !
+
+!HLCodeHandled class methodsFor: 'actions'!
+
+on: aCodeModel
+
+	^ self new 
+    	code: aCodeModel;
+        yourself
+! !
+
+HLCodeHandled subclass: #HLDoItExecuted
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+!HLDoItExecuted commentStamp!
+I am emitted by a `HLCodeWidget` after a DoIt has been executed.!
+
+HLAnnouncement subclass: #HLDebuggerAnnouncement
+	instanceVariableNames: 'context'
+	package: 'Helios-Announcements'!
+!HLDebuggerAnnouncement commentStamp!
+I am the root class of debugger announcements, and hold onto the debugged `context`.!
+
+!HLDebuggerAnnouncement methodsFor: 'accessing'!
+
+context
+	^ context
+!
+
+context: aContext
+	context := aContext
+! !
+
+HLDebuggerAnnouncement subclass: #HLDebuggerContextSelected
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+!HLDebuggerContextSelected commentStamp!
+I am announced when a new context is selected in a debugger, to update the user interface.!
+
+!HLDebuggerContextSelected methodsFor: 'accessing'!
+
+context
+	^ context
+!
+
+context: aContext
+	context := aContext
+! !
+
+HLDebuggerAnnouncement subclass: #HLDebuggerProceeded
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLDebuggerAnnouncement subclass: #HLDebuggerStepped
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLDebuggerAnnouncement subclass: #HLDebuggerWhere
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLDiveRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLEditComment
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLErrorRaised
+	instanceVariableNames: 'error'
+	package: 'Helios-Announcements'!
+
+!HLErrorRaised methodsFor: 'accessing'!
+
+error
+	^ error
+!
+
+error: anError
+	error := anError
+! !
+
+HLErrorRaised subclass: #HLCompileErrorRaised
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLErrorRaised subclass: #HLParseErrorRaised
+	instanceVariableNames: 'line column message'
+	package: 'Helios-Announcements'!
+
+!HLParseErrorRaised methodsFor: 'accessing'!
+
+column
+	^ column
+!
+
+column: anInteger
+	column := anInteger
+!
+
+line
+	^ line
+!
+
+line: anInteger
+	line := anInteger
+!
+
+message
+	^ message
+!
+
+message: aString
+	message := aString
+! !
+
+HLErrorRaised subclass: #HLUnknownVariableErrorRaised
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLFocusRequested subclass: #HLClassesFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLFocusRequested subclass: #HLDocumentationFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLFocusRequested subclass: #HLMethodsFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLFocusRequested subclass: #HLPackagesFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLFocusRequested subclass: #HLProtocolsFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLFocusRequested subclass: #HLSourceCodeFocusRequested
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLInstVarAdded
+	instanceVariableNames: 'theClass variableName'
+	package: 'Helios-Announcements'!
+
+!HLInstVarAdded methodsFor: 'accessing'!
+
+theClass
+	^ theClass
+!
+
+theClass: aClass
+	theClass := aClass
+!
+
+variableName
+	^ variableName
+!
+
+variableName: aString
+	variableName := aString
+! !
+
+HLAnnouncement subclass: #HLItemSelected
+	instanceVariableNames: 'item'
+	package: 'Helios-Announcements'!
+
+!HLItemSelected methodsFor: 'accessing'!
+
+item
+	^ item
+!
+
+item: anObject
+	item := anObject
+! !
+
+!HLItemSelected class methodsFor: 'instance creation'!
+
+on: anItem
+	^ self new
+    	item: anItem;
+        yourself
+! !
+
+HLItemSelected subclass: #HLClassSelected
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLItemSelected subclass: #HLInstanceVariableSelected
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLItemSelected subclass: #HLMethodSelected
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLItemSelected subclass: #HLPackageSelected
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLItemSelected subclass: #HLProtocolSelected
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLSaveSourceCode
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLSearchReferences
+	instanceVariableNames: 'searchString'
+	package: 'Helios-Announcements'!
+
+!HLSearchReferences methodsFor: 'accessing'!
+
+searchString
+	^ searchString
+!
+
+searchString: aString
+	searchString := aString
+! !
+
+HLAnnouncement subclass: #HLShowCommentToggled
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLShowInstanceToggled
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLShowTemplate
+	instanceVariableNames: 'template'
+	package: 'Helios-Announcements'!
+
+!HLShowTemplate methodsFor: 'accessing'!
+
+template
+	^ template
+!
+
+template: aString
+	template := aString
+! !
+
+HLAnnouncement subclass: #HLSourceCodeSaved
+	instanceVariableNames: ''
+	package: 'Helios-Announcements'!
+
+HLAnnouncement subclass: #HLTabLabelChanged
+	instanceVariableNames: 'label widget'
+	package: 'Helios-Announcements'!
+
+!HLTabLabelChanged methodsFor: 'accessing'!
+
+label
+	^ label
+!
+
+label: aString
+	label := aString
+!
+
+widget
+	^ widget
+!
+
+widget: aWidget
+	widget := aWidget
+! !
+

src/Helios-Browser.js

@@ -0,0 +1,4383 @@
+define("helios/Helios-Browser", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Core", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Browser');
+smalltalk.packages["Helios-Browser"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLBrowser', globals.HLWidget, ['model', 'packagesListWidget', 'classesListWidget', 'protocolsListWidget', 'methodsListWidget', 'sourceWidget', 'bottomDiv'], 'Helios-Browser');
+globals.HLBrowser.comment="I render a system browser with 4 panes (Packages, Classes, Protocols, Methods) and a source area.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canHaveFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canHaveFocus\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classesListWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLClassesListWidget(){return globals.HLClassesListWidget||(typeof HLClassesListWidget=="undefined"?nil:HLClassesListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@classesListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@classesListWidget"]=_st($HLClassesListWidget())._on_(self._model());
+self["@classesListWidget"];
+$1=_st(self["@classesListWidget"])._next_(self._protocolsListWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"classesListWidget",{},globals.HLBrowser)})},
+args: [],
+source: "classesListWidget\x0a\x09^ classesListWidget ifNil: [\x0a      \x09classesListWidget := HLClassesListWidget on: self model.\x0a\x09\x09classesListWidget next: self protocolsListWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "protocolsListWidget"],
+referencedClasses: ["HLClassesListWidget"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._environment();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"environment",{},globals.HLBrowser)})},
+args: [],
+source: "environment\x0a\x09^ self model environment",
+messageSends: ["environment", "model"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._packagesListWidget())._focus();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLBrowser)})},
+args: [],
+source: "focus\x0a\x09^ self packagesListWidget focus",
+messageSends: ["focus", "packagesListWidget"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodsListWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLMethodsListWidget(){return globals.HLMethodsListWidget||(typeof HLMethodsListWidget=="undefined"?nil:HLMethodsListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@methodsListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@methodsListWidget"]=_st($HLMethodsListWidget())._on_(self._model());
+self["@methodsListWidget"];
+$1=_st(self["@methodsListWidget"])._next_(self._sourceWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"methodsListWidget",{},globals.HLBrowser)})},
+args: [],
+source: "methodsListWidget\x0a\x09^ methodsListWidget ifNil: [\x0a      \x09methodsListWidget := HLMethodsListWidget on: self model.\x0a\x09\x09methodsListWidget next: self sourceWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "sourceWidget"],
+referencedClasses: ["HLMethodsListWidget"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLBrowserModel(){return globals.HLBrowserModel||(typeof HLBrowserModel=="undefined"?nil:HLBrowserModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@model"];
+if(($receiver = $2) == null || $receiver.isNil){
+self._model_(_st($HLBrowserModel())._new());
+$1=self["@model"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLBrowser)})},
+args: [],
+source: "model\x0a\x09^ model ifNil: [ self model: HLBrowserModel new. model ]",
+messageSends: ["ifNil:", "model:", "new"],
+referencedClasses: ["HLBrowserModel"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@model"]=aModel;
+self._observeModel();
+return self}, function($ctx1) {$ctx1.fill(self,"model:",{aModel:aModel},globals.HLBrowser)})},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel.\x0a\x09self observeModel",
+messageSends: ["observeModel"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=self._model();
+$ctx1.sendIdx["model"]=1;
+$1=_st($2)._announcer();
+$ctx1.sendIdx["announcer"]=1;
+_st($1)._on_send_to_($HLPackageSelected(),"onPackageSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st(_st(self._model())._announcer())._on_send_to_($HLClassSelected(),"onClassSelected:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLBrowser)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer\x0a\x09\x09on: HLPackageSelected\x0a\x09\x09send: #onPackageSelected:\x0a\x09\x09to: self.\x0a\x09\x09\x0a\x09self model announcer\x0a\x09\x09on: HLClassSelected\x0a\x09\x09send: #onClassSelected:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLPackageSelected", "HLClassSelected"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$receiver;
+$1=_st(anAnnouncement)._item();
+if(($receiver = $1) == null || $receiver.isNil){
+$3=_st(self._model())._selectedPackage();
+if(($receiver = $3) == null || $receiver.isNil){
+$2=self._defaultTabLabel();
+} else {
+var package_;
+package_=$receiver;
+$2=_st(package_)._name();
+$ctx1.sendIdx["name"]=1;
+};
+self._setTabLabel_($2);
+$ctx1.sendIdx["setTabLabel:"]=1;
+} else {
+var item;
+item=$receiver;
+self._setTabLabel_(_st(item)._name());
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement},globals.HLBrowser)})},
+args: ["anAnnouncement"],
+source: "onClassSelected: anAnnouncement\x0a\x09anAnnouncement item \x0a\x09\x09ifNil: [ self setTabLabel: (self model selectedPackage \x0a\x09\x09\x09ifNil: [ self defaultTabLabel ]\x0a\x09\x09\x09ifNotNil: [ :package | package name ]) ] \x0a\x09\x09ifNotNil: [ :item | self setTabLabel: item name ]",
+messageSends: ["ifNil:ifNotNil:", "item", "setTabLabel:", "selectedPackage", "model", "defaultTabLabel", "name"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=_st(anAnnouncement)._item();
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+var item;
+item=$receiver;
+self._setTabLabel_(_st(item)._name());
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageSelected:",{anAnnouncement:anAnnouncement},globals.HLBrowser)})},
+args: ["anAnnouncement"],
+source: "onPackageSelected: anAnnouncement\x0a\x09anAnnouncement item ifNotNil: [ :item |\x0a\x09self setTabLabel: item name ]",
+messageSends: ["ifNotNil:", "item", "setTabLabel:", "name"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openClassNamed:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._openClassNamed_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"openClassNamed:",{aString:aString},globals.HLBrowser)})},
+args: ["aString"],
+source: "openClassNamed: aString\x0a\x09self model openClassNamed: aString",
+messageSends: ["openClassNamed:", "model"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openMethod:",
+protocol: 'actions',
+fn: function (aCompiledMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$5;
+$1=self._model();
+_st($1)._focusOnSourceCode();
+$ctx1.sendIdx["focusOnSourceCode"]=1;
+$2=$1;
+$4=_st(aCompiledMethod)._methodClass();
+$ctx1.sendIdx["methodClass"]=1;
+$3=_st($4)._package();
+_st($2)._selectedPackage_($3);
+_st($1)._selectedClass_(_st(aCompiledMethod)._methodClass());
+_st($1)._selectedProtocol_(_st(aCompiledMethod)._protocol());
+_st($1)._selectedMethod_(aCompiledMethod);
+$5=_st($1)._focusOnSourceCode();
+return self}, function($ctx1) {$ctx1.fill(self,"openMethod:",{aCompiledMethod:aCompiledMethod},globals.HLBrowser)})},
+args: ["aCompiledMethod"],
+source: "openMethod: aCompiledMethod\x0a\x09self model\x0a\x09\x09\x22Workaround for the package selection announcement when the package list is focused\x22\x09\x0a\x09\x09focusOnSourceCode;\x0a\x09\x09selectedPackage: aCompiledMethod methodClass package;\x0a\x09\x09selectedClass: aCompiledMethod methodClass;\x0a\x09\x09selectedProtocol: aCompiledMethod protocol;\x0a\x09\x09selectedMethod: aCompiledMethod;\x0a\x09\x09focusOnSourceCode",
+messageSends: ["focusOnSourceCode", "model", "selectedPackage:", "package", "methodClass", "selectedClass:", "selectedProtocol:", "protocol", "selectedMethod:"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "packagesListWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLPackagesListWidget(){return globals.HLPackagesListWidget||(typeof HLPackagesListWidget=="undefined"?nil:HLPackagesListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@packagesListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@packagesListWidget"]=_st($HLPackagesListWidget())._on_(self._model());
+self["@packagesListWidget"];
+$1=_st(self["@packagesListWidget"])._next_(self._classesListWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"packagesListWidget",{},globals.HLBrowser)})},
+args: [],
+source: "packagesListWidget\x0a\x09^ packagesListWidget ifNil: [\x0a      \x09packagesListWidget := HLPackagesListWidget on: self model.\x0a\x09\x09packagesListWidget next: self classesListWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "classesListWidget"],
+referencedClasses: ["HLPackagesListWidget"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "protocolsListWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLProtocolsListWidget(){return globals.HLProtocolsListWidget||(typeof HLProtocolsListWidget=="undefined"?nil:HLProtocolsListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@protocolsListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@protocolsListWidget"]=_st($HLProtocolsListWidget())._on_(self._model());
+self["@protocolsListWidget"];
+$1=_st(self["@protocolsListWidget"])._next_(self._methodsListWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"protocolsListWidget",{},globals.HLBrowser)})},
+args: [],
+source: "protocolsListWidget\x0a\x09^ protocolsListWidget ifNil: [\x0a      \x09protocolsListWidget := HLProtocolsListWidget on: self model.\x0a\x09\x09protocolsListWidget next: self methodsListWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "methodsListWidget"],
+referencedClasses: ["HLProtocolsListWidget"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerBindingsOn:",
+protocol: 'keybindings',
+fn: function (aBindingGroup){
+var self=this;
+function $HLToolCommand(){return globals.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLToolCommand())._registerConcreteClassesOn_for_(aBindingGroup,self._model());
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},globals.HLBrowser)})},
+args: ["aBindingGroup"],
+source: "registerBindingsOn: aBindingGroup\x0a\x09HLToolCommand \x0a\x09\x09registerConcreteClassesOn: aBindingGroup \x0a\x09\x09for: self model",
+messageSends: ["registerConcreteClassesOn:for:", "model"],
+referencedClasses: ["HLToolCommand"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+var $5,$4,$3,$2,$1;
+$5=self._packagesListWidget();
+$ctx1.sendIdx["packagesListWidget"]=1;
+$4=_st($HLVerticalSplitter())._with_with_($5,self._classesListWidget());
+$ctx1.sendIdx["with:with:"]=3;
+$3=_st($HLVerticalSplitter())._with_with_($4,_st($HLVerticalSplitter())._with_with_(self._protocolsListWidget(),self._methodsListWidget()));
+$ctx1.sendIdx["with:with:"]=2;
+$2=_st($HLHorizontalSplitter())._with_with_($3,self._sourceWidget());
+$ctx1.sendIdx["with:with:"]=1;
+$1=_st($HLContainer())._with_($2);
+_st(html)._with_($1);
+$ctx1.sendIdx["with:"]=1;
+_st(self._packagesListWidget())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLBrowser)})},
+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: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sourceWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLBrowserBottomWidget(){return globals.HLBrowserBottomWidget||(typeof HLBrowserBottomWidget=="undefined"?nil:HLBrowserBottomWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@sourceWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLBrowserBottomWidget())._new();
+_st($3)._model_(self._model());
+$4=_st($3)._yourself();
+self["@sourceWidget"]=$4;
+$1=self["@sourceWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"sourceWidget",{},globals.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:", "new", "model", "yourself"],
+referencedClasses: ["HLBrowserBottomWidget"]
+}),
+globals.HLBrowser);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLBrowser.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+$ctx1.sendIdx["unregister"]=1;
+_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,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.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 ]",
+messageSends: ["unregister", "do:", "packagesListWidget", "classesListWidget", "protocolsListWidget", "methodsListWidget", "sourceWidget"],
+referencedClasses: []
+}),
+globals.HLBrowser);
+
+
+globals.HLBrowser.klass.iVarNames = ['nextId'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowser.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "nextId",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+$1=self["@nextId"];
+if(($receiver = $1) == null || $receiver.isNil){
+self["@nextId"]=(0);
+self["@nextId"];
+} else {
+$1;
+};
+$2="browser_".__comma(_st(_st(self["@nextId"]).__plus((1)))._asString());
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"nextId",{},globals.HLBrowser.klass)})},
+args: [],
+source: "nextId\x0a\x09nextId ifNil: [ nextId := 0 ].\x0a    ^ 'browser_', (nextId + 1) asString",
+messageSends: ["ifNil:", ",", "asString", "+"],
+referencedClasses: []
+}),
+globals.HLBrowser.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "browser";
+},
+args: [],
+source: "tabClass\x0a\x09^ 'browser'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowser.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Browser";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'Browser'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowser.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabPriority",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (0);
+},
+args: [],
+source: "tabPriority\x0a\x09^ 0",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowser.klass);
+
+
+smalltalk.addClass('HLBrowserBottomWidget', globals.HLWidget, ['model', 'codeWidget', 'documentationWidget'], 'Helios-Browser');
+globals.HLBrowserBottomWidget.comment="I render the code area of a browser and optionally the documentation for the selected class.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canHaveFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canHaveFocus\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "codeWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLBrowserCodeWidget(){return globals.HLBrowserCodeWidget||(typeof HLBrowserCodeWidget=="undefined"?nil:HLBrowserCodeWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@codeWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLBrowserCodeWidget())._new();
+_st($3)._browserModel_(self._model());
+$4=_st($3)._yourself();
+self["@codeWidget"]=$4;
+$1=self["@codeWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"codeWidget",{},globals.HLBrowserBottomWidget)})},
+args: [],
+source: "codeWidget\x0a\x09^ codeWidget ifNil: [ codeWidget := HLBrowserCodeWidget new\x0a\x09\x09browserModel: self model;\x0a\x09\x09yourself ]",
+messageSends: ["ifNil:", "browserModel:", "new", "model", "yourself"],
+referencedClasses: ["HLBrowserCodeWidget"]
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "documentationWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLDocumentationWidget(){return globals.HLDocumentationWidget||(typeof HLDocumentationWidget=="undefined"?nil:HLDocumentationWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@documentationWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLDocumentationWidget())._new();
+_st($3)._model_(self._model());
+$4=_st($3)._yourself();
+self["@documentationWidget"]=$4;
+$1=self["@documentationWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"documentationWidget",{},globals.HLBrowserBottomWidget)})},
+args: [],
+source: "documentationWidget\x0a\x09^ documentationWidget ifNil: [ documentationWidget := HLDocumentationWidget new\x0a\x09\x09model: self model;\x0a\x09\x09yourself ]",
+messageSends: ["ifNil:", "model:", "new", "model", "yourself"],
+referencedClasses: ["HLDocumentationWidget"]
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._codeWidget())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLBrowserBottomWidget)})},
+args: [],
+source: "focus\x0a\x09self codeWidget focus",
+messageSends: ["focus", "codeWidget"],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@model"];
+return $1;
+},
+args: [],
+source: "model\x0a\x09^ model",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@model"]=aModel;
+self._observeModel();
+return self}, function($ctx1) {$ctx1.fill(self,"model:",{aModel:aModel},globals.HLBrowserBottomWidget)})},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel.\x0a\x09self observeModel",
+messageSends: ["observeModel"],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLShowInstanceToggled(){return globals.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
+function $HLShowCommentToggled(){return globals.HLShowCommentToggled||(typeof HLShowCommentToggled=="undefined"?nil:HLShowCommentToggled)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLShowInstanceToggled(),"onShowInstanceToggled",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+$2=_st($1)._on_send_to_($HLShowCommentToggled(),"onShowCommentToggled",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLBrowserBottomWidget)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer \x0a\x09\x09on: HLShowInstanceToggled\x0a\x09\x09send: #onShowInstanceToggled\x0a\x09\x09to: self;\x0a\x09\x09on: HLShowCommentToggled\x0a\x09\x09send: #onShowCommentToggled\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLShowInstanceToggled", "HLShowCommentToggled"]
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowCommentToggled",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onShowCommentToggled",{},globals.HLBrowserBottomWidget)})},
+args: [],
+source: "onShowCommentToggled\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowInstanceToggled",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onShowInstanceToggled",{},globals.HLBrowserBottomWidget)})},
+args: [],
+source: "onShowInstanceToggled\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previous",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "previous\x0a\x09\x22For navigation\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previous:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+return self},
+args: ["aWidget"],
+source: "previous: aWidget\x0a\x09\x22For navigation\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._showComment();
+if(smalltalk.assert($1)){
+self._renderPanesOn_(html);
+} else {
+_st(html)._with_(self._codeWidget());
+};
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.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:", "showComment", "model", "renderPanesOn:", "with:", "codeWidget"],
+referencedClasses: []
+}),
+globals.HLBrowserBottomWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderPanesOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+_st(html)._with_(_st($HLVerticalSplitter())._with_with_(self._codeWidget(),self._documentationWidget()));
+return self}, function($ctx1) {$ctx1.fill(self,"renderPanesOn:",{html:html},globals.HLBrowserBottomWidget)})},
+args: ["html"],
+source: "renderPanesOn: html\x0a\x09html with: (HLVerticalSplitter\x0a\x09\x09with: self codeWidget\x0a\x09\x09with: self documentationWidget)",
+messageSends: ["with:", "with:with:", "codeWidget", "documentationWidget"],
+referencedClasses: ["HLVerticalSplitter"]
+}),
+globals.HLBrowserBottomWidget);
+
+
+
+smalltalk.addClass('HLBrowserModel', globals.HLToolModel, ['showInstance', 'showComment'], 'Helios-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "editComment",
+protocol: 'commands actions',
+fn: function (){
+var self=this;
+function $HLEditComment(){return globals.HLEditComment||(typeof HLEditComment=="undefined"?nil:HLEditComment)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLEditComment())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"editComment",{},globals.HLBrowserModel)})},
+args: [],
+source: "editComment\x0a\x09self announcer announce: HLEditComment new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLEditComment"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusOnClasses",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLClassesFocusRequested(){return globals.HLClassesFocusRequested||(typeof HLClassesFocusRequested=="undefined"?nil:HLClassesFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLClassesFocusRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusOnClasses",{},globals.HLBrowserModel)})},
+args: [],
+source: "focusOnClasses\x0a\x09self announcer announce: HLClassesFocusRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLClassesFocusRequested"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusOnDocumentation",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDocumentationFocusRequested(){return globals.HLDocumentationFocusRequested||(typeof HLDocumentationFocusRequested=="undefined"?nil:HLDocumentationFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLDocumentationFocusRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusOnDocumentation",{},globals.HLBrowserModel)})},
+args: [],
+source: "focusOnDocumentation\x0a\x09self announcer announce: HLDocumentationFocusRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLDocumentationFocusRequested"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusOnMethods",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLMethodsFocusRequested(){return globals.HLMethodsFocusRequested||(typeof HLMethodsFocusRequested=="undefined"?nil:HLMethodsFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLMethodsFocusRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusOnMethods",{},globals.HLBrowserModel)})},
+args: [],
+source: "focusOnMethods\x0a\x09self announcer announce: HLMethodsFocusRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLMethodsFocusRequested"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusOnPackages",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLPackagesFocusRequested(){return globals.HLPackagesFocusRequested||(typeof HLPackagesFocusRequested=="undefined"?nil:HLPackagesFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLPackagesFocusRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusOnPackages",{},globals.HLBrowserModel)})},
+args: [],
+source: "focusOnPackages\x0a\x09self announcer announce: HLPackagesFocusRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLPackagesFocusRequested"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusOnProtocols",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLProtocolsFocusRequested(){return globals.HLProtocolsFocusRequested||(typeof HLProtocolsFocusRequested=="undefined"?nil:HLProtocolsFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLProtocolsFocusRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusOnProtocols",{},globals.HLBrowserModel)})},
+args: [],
+source: "focusOnProtocols\x0a\x09self announcer announce: HLProtocolsFocusRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLProtocolsFocusRequested"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusOnSourceCode",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLSourceCodeFocusRequested(){return globals.HLSourceCodeFocusRequested||(typeof HLSourceCodeFocusRequested=="undefined"?nil:HLSourceCodeFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLSourceCodeFocusRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusOnSourceCode",{},globals.HLBrowserModel)})},
+args: [],
+source: "focusOnSourceCode\x0a\x09self announcer announce: HLSourceCodeFocusRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLSourceCodeFocusRequested"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isBrowserModel",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isBrowserModel\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setClassComment:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._setClassCommentOf_to_(_st(self._selectedClass())._theNonMetaClass(),aString);
+return self}, function($ctx1) {$ctx1.fill(self,"setClassComment:",{aString:aString},globals.HLBrowserModel)})},
+args: ["aString"],
+source: "setClassComment: aString\x0a\x09self environment\x0a\x09\x09setClassCommentOf: self selectedClass theNonMetaClass\x0a\x09\x09to: aString",
+messageSends: ["setClassCommentOf:to:", "environment", "theNonMetaClass", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showClassTemplate",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLShowTemplate(){return globals.HLShowTemplate||(typeof HLShowTemplate=="undefined"?nil:HLShowTemplate)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$receiver;
+$1=self._selectedPackage();
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+var package_;
+package_=$receiver;
+$2=_st($HLShowTemplate())._new();
+_st($2)._template_(_st(package_)._classTemplate());
+$3=_st($2)._yourself();
+_st(self._announcer())._announce_($3);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"showClassTemplate",{},globals.HLBrowserModel)})},
+args: [],
+source: "showClassTemplate\x0a\x09self selectedPackage ifNotNil: [ :package |\x0a\x09\x09self announcer announce: (HLShowTemplate new\x0a\x09\x09\x09template: package classTemplate;\x0a\x09\x09\x09yourself) ]",
+messageSends: ["ifNotNil:", "selectedPackage", "announce:", "announcer", "template:", "new", "classTemplate", "yourself"],
+referencedClasses: ["HLShowTemplate"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showComment",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@showComment"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=true;
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"showComment",{},globals.HLBrowserModel)})},
+args: [],
+source: "showComment\x0a\x09^ showComment ifNil: [ true ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showComment:",
+protocol: 'accessing',
+fn: function (aBoolean){
+var self=this;
+function $HLShowCommentToggled(){return globals.HLShowCommentToggled||(typeof HLShowCommentToggled=="undefined"?nil:HLShowCommentToggled)}
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@showComment"]=aBoolean;
+self["@showComment"];
+return _st(self._announcer())._announce_(_st($HLShowCommentToggled())._new());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"showComment:",{aBoolean:aBoolean},globals.HLBrowserModel)})},
+args: ["aBoolean"],
+source: "showComment: aBoolean\x0a\x09self withChangesDo: [\x0a\x09\x09showComment := aBoolean.\x0a\x09\x09self announcer announce: HLShowCommentToggled new ]",
+messageSends: ["withChangesDo:", "announce:", "announcer", "new"],
+referencedClasses: ["HLShowCommentToggled"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showInstance",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@showInstance"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=true;
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"showInstance",{},globals.HLBrowserModel)})},
+args: [],
+source: "showInstance\x0a\x09^ showInstance ifNil: [ true ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showInstance:",
+protocol: 'accessing',
+fn: function (aBoolean){
+var self=this;
+function $HLShowInstanceToggled(){return globals.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$receiver;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@showInstance"]=aBoolean;
+self["@showInstance"];
+$1=self._selectedClass();
+$ctx2.sendIdx["selectedClass"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+if(smalltalk.assert(aBoolean)){
+$3=self._selectedClass();
+$ctx2.sendIdx["selectedClass"]=2;
+$2=_st($3)._theNonMetaClass();
+} else {
+$2=_st(self._selectedClass())._theMetaClass();
+};
+self._selectedClass_($2);
+};
+return _st(self._announcer())._announce_(_st($HLShowInstanceToggled())._new());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"showInstance:",{aBoolean:aBoolean},globals.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", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "theMetaClass", "announce:", "announcer", "new"],
+referencedClasses: ["HLShowInstanceToggled"]
+}),
+globals.HLBrowserModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showMethodTemplate",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLShowTemplate(){return globals.HLShowTemplate||(typeof HLShowTemplate=="undefined"?nil:HLShowTemplate)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$receiver;
+$1=self._selectedClass();
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+var theClass;
+theClass=$receiver;
+$2=_st($HLShowTemplate())._new();
+_st($2)._template_(_st(theClass)._methodTemplate());
+$3=_st($2)._yourself();
+_st(self._announcer())._announce_($3);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"showMethodTemplate",{},globals.HLBrowserModel)})},
+args: [],
+source: "showMethodTemplate\x0a\x09self selectedClass ifNotNil: [ :theClass |\x0a\x09\x09self announcer announce: (HLShowTemplate new\x0a\x09\x09\x09template: theClass methodTemplate;\x0a\x09\x09\x09yourself) ]",
+messageSends: ["ifNotNil:", "selectedClass", "announce:", "announcer", "template:", "new", "methodTemplate", "yourself"],
+referencedClasses: ["HLShowTemplate"]
+}),
+globals.HLBrowserModel);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (anEnvironment){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._environment_(anEnvironment);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anEnvironment:anEnvironment},globals.HLBrowserModel.klass)})},
+args: ["anEnvironment"],
+source: "on: anEnvironment\x0a\x0a\x09^ self new\x0a    \x09environment: anEnvironment;\x0a        yourself",
+messageSends: ["environment:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLBrowserModel.klass);
+
+
+smalltalk.addClass('HLClassCache', globals.Object, ['class', 'selectorsCache', 'overrideCache', 'overriddenCache'], 'Helios-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "invalidateChildrenSelector:",
+protocol: 'actions',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st(_st(self._theClass())._subclasses())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(self._selectorsCache())._cacheFor_(each);
+_st($1)._removeSelector_(aSelector);
+$2=_st($1)._invalidateChildrenSelector_(aSelector);
+return $2;
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"invalidateChildrenSelector:",{aSelector:aSelector},globals.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:", "subclasses", "theClass", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateChildrenSelector:"],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "invalidateParentSelector:",
+protocol: 'actions',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$4,$receiver;
+$2=self._theClass();
+$ctx1.sendIdx["theClass"]=1;
+$1=_st($2)._superclass();
+$ctx1.sendIdx["superclass"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+$3=_st(self._selectorsCache())._cacheFor_(_st(self._theClass())._superclass());
+_st($3)._removeSelector_(aSelector);
+$4=_st($3)._invalidateParentSelector_(aSelector);
+$4;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"invalidateParentSelector:",{aSelector:aSelector},globals.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:", "superclass", "theClass", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateParentSelector:"],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "invalidateSelector:",
+protocol: 'actions',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._invalidateParentSelector_(aSelector);
+self._invalidateChildrenSelector_(aSelector);
+$1=self._removeSelector_(aSelector);
+return self}, function($ctx1) {$ctx1.fill(self,"invalidateSelector:",{aSelector:aSelector},globals.HLClassCache)})},
+args: ["aSelector"],
+source: "invalidateSelector: aSelector\x0a\x09self \x0a    \x09invalidateParentSelector: aSelector;\x0a        invalidateChildrenSelector: aSelector;\x0a        removeSelector: aSelector",
+messageSends: ["invalidateParentSelector:", "invalidateChildrenSelector:", "removeSelector:"],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isOverridden:",
+protocol: 'testing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+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,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isOverridden:",{aMethod:aMethod},globals.HLClassCache)})},
+args: ["aMethod"],
+source: "isOverridden: aMethod\x0a\x09^ self overriddenCache \x0a    \x09at: aMethod selector\x0a      \x09ifAbsentPut: [ aMethod isOverridden ]",
+messageSends: ["at:ifAbsentPut:", "overriddenCache", "selector", "isOverridden"],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isOverride:",
+protocol: 'testing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+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,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isOverride:",{aMethod:aMethod},globals.HLClassCache)})},
+args: ["aMethod"],
+source: "isOverride: aMethod\x0a\x09^ self overrideCache\x0a    \x09at: aMethod selector\x0a      \x09ifAbsentPut: [ aMethod isOverride ]",
+messageSends: ["at:ifAbsentPut:", "overrideCache", "selector", "isOverride"],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "overriddenCache",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@overriddenCache"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@overriddenCache"]=_st($HashedCollection())._new();
+$1=self["@overriddenCache"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"overriddenCache",{},globals.HLClassCache)})},
+args: [],
+source: "overriddenCache\x0a\x09^ overriddenCache ifNil: [ overriddenCache := HashedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HashedCollection"]
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "overrideCache",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@overrideCache"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@overrideCache"]=_st($HashedCollection())._new();
+$1=self["@overrideCache"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"overrideCache",{},globals.HLClassCache)})},
+args: [],
+source: "overrideCache\x0a\x09^ overrideCache ifNil: [ overrideCache := HashedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HashedCollection"]
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeSelector:",
+protocol: 'private',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._overriddenCache())._removeKey_ifAbsent_(aSelector,(function(){
+}));
+$ctx1.sendIdx["removeKey:ifAbsent:"]=1;
+_st(self._overrideCache())._removeKey_ifAbsent_(aSelector,(function(){
+}));
+return self}, function($ctx1) {$ctx1.fill(self,"removeSelector:",{aSelector:aSelector},globals.HLClassCache)})},
+args: ["aSelector"],
+source: "removeSelector: aSelector\x0a\x09self overriddenCache \x0a    \x09removeKey: aSelector\x0a        ifAbsent: [ ].\x0a    self overrideCache \x0a    \x09removeKey: aSelector\x0a        ifAbsent: [ ]",
+messageSends: ["removeKey:ifAbsent:", "overriddenCache", "overrideCache"],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectorsCache",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selectorsCache"];
+return $1;
+},
+args: [],
+source: "selectorsCache\x0a\x09^ selectorsCache",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectorsCache:",
+protocol: 'accessing',
+fn: function (aCache){
+var self=this;
+self["@selectorsCache"]=aCache;
+return self},
+args: ["aCache"],
+source: "selectorsCache: aCache\x0a\x09selectorsCache := aCache",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "theClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@class"];
+return $1;
+},
+args: [],
+source: "theClass\x0a\x09^ class",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "theClass:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+self["@class"]=aClass;
+return self},
+args: ["aClass"],
+source: "theClass: aClass\x0a\x09class := aClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassCache);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:selectorsCache:",
+protocol: 'instance creation',
+fn: function (aClass,aSelectorsCache){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._theClass_(aClass);
+_st($2)._selectorsCache_(aSelectorsCache);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:selectorsCache:",{aClass:aClass,aSelectorsCache:aSelectorsCache},globals.HLClassCache.klass)})},
+args: ["aClass", "aSelectorsCache"],
+source: "on: aClass selectorsCache: aSelectorsCache\x0a\x09^ self new\x0a    \x09theClass: aClass;\x0a        selectorsCache: aSelectorsCache;\x0a        yourself",
+messageSends: ["theClass:", "new", "selectorsCache:", "yourself"],
+referencedClasses: []
+}),
+globals.HLClassCache.klass);
+
+
+smalltalk.addClass('HLClassesListWidget', globals.HLToolListWidget, [], 'Helios-Browser');
+globals.HLClassesListWidget.comment="I render a list of classes in the selected package.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClassForItem:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(aClass)._theNonMetaClass())._heliosClass();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClassForItem:",{aClass:aClass},globals.HLClassesListWidget)})},
+args: ["aClass"],
+source: "cssClassForItem: aClass\x0a\x09^ aClass theNonMetaClass heliosClass",
+messageSends: ["heliosClass", "theNonMetaClass"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+($ctx1.supercall = true, globals.HLClassesListWidget.superclass.fn.prototype._focus.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=self._selectedItem();
+if(($receiver = $1) == null || $receiver.isNil){
+_st(self._model())._showClassTemplate();
+} else {
+$1;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLClassesListWidget)})},
+args: [],
+source: "focus\x0a\x09super focus.\x0a\x09\x0a\x09self selectedItem \x0a\x09\x09ifNil: [ self model showClassTemplate ]",
+messageSends: ["focus", "ifNil:", "selectedItem", "showClassTemplate", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusMethodsListWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLMethodsListFocus(){return globals.HLMethodsListFocus||(typeof HLMethodsListFocus=="undefined"?nil:HLMethodsListFocus)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._model())._announcer())._announce_(_st($HLMethodsListFocus())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusMethodsListWidget",{},globals.HLClassesListWidget)})},
+args: [],
+source: "focusMethodsListWidget\x0a\x09self model announcer announce: HLMethodsListFocus new",
+messageSends: ["announce:", "announcer", "model", "new"],
+referencedClasses: ["HLMethodsListFocus"]
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusProtocolsListWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLProtocolsListFocus(){return globals.HLProtocolsListFocus||(typeof HLProtocolsListFocus=="undefined"?nil:HLProtocolsListFocus)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._model())._announcer())._announce_(_st($HLProtocolsListFocus())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusProtocolsListWidget",{},globals.HLClassesListWidget)})},
+args: [],
+source: "focusProtocolsListWidget\x0a\x09self model announcer announce: HLProtocolsListFocus new",
+messageSends: ["announce:", "announcer", "model", "new"],
+referencedClasses: ["HLProtocolsListFocus"]
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "getChildrenOf:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+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,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"getChildrenOf:",{aClass:aClass},globals.HLClassesListWidget)})},
+args: ["aClass"],
+source: "getChildrenOf: aClass\x0a\x09^ self items select: [ :each | each superclass = aClass ]",
+messageSends: ["select:", "items", "=", "superclass"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "getRootClassesOf:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+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,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"getRootClassesOf:",{aCollection:aCollection},globals.HLClassesListWidget)})},
+args: ["aCollection"],
+source: "getRootClassesOf: aCollection\x0a\x09^ aCollection select: [ :each |\x0a    \x09\x09(aCollection includes: each superclass) not ]",
+messageSends: ["select:", "not", "includes:", "superclass"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "label\x0a\x09^ 'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+function $HLShowInstanceToggled(){return globals.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
+function $HLShowCommentToggled(){return globals.HLShowCommentToggled||(typeof HLShowCommentToggled=="undefined"?nil:HLShowCommentToggled)}
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+function $HLClassesFocusRequested(){return globals.HLClassesFocusRequested||(typeof HLClassesFocusRequested=="undefined"?nil:HLClassesFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLPackageSelected(),"onPackageSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($HLShowInstanceToggled(),"onShowInstanceToggled",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st($1)._on_send_to_($HLShowCommentToggled(),"onShowCommentToggled",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+_st($1)._on_send_to_($HLClassSelected(),"onClassSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=4;
+$2=_st($1)._on_send_to_($HLClassesFocusRequested(),"onClassesFocusRequested",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLClassesListWidget)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer \x0a    \x09on: HLPackageSelected\x0a\x09\x09send: #onPackageSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a    \x09on: HLShowInstanceToggled \x0a\x09\x09send: #onShowInstanceToggled\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLShowCommentToggled\x0a\x09\x09send: #onShowCommentToggled\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLClassSelected\x0a\x09\x09send: #onClassSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLClassesFocusRequested\x0a\x09\x09send: #onClassesFocusRequested\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLPackageSelected", "HLShowInstanceToggled", "HLShowCommentToggled", "HLClassSelected", "HLClassesFocusRequested"]
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $ClassAdded(){return globals.ClassAdded||(typeof ClassAdded=="undefined"?nil:ClassAdded)}
+function $ClassRemoved(){return globals.ClassRemoved||(typeof ClassRemoved=="undefined"?nil:ClassRemoved)}
+function $ClassMoved(){return globals.ClassMoved||(typeof ClassMoved=="undefined"?nil:ClassMoved)}
+function $ClassRenamed(){return globals.ClassRenamed||(typeof ClassRenamed=="undefined"?nil:ClassRenamed)}
+function $ClassMigrated(){return globals.ClassMigrated||(typeof ClassMigrated=="undefined"?nil:ClassMigrated)}
+function $ClassCommentChanged(){return globals.ClassCommentChanged||(typeof ClassCommentChanged=="undefined"?nil:ClassCommentChanged)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._systemAnnouncer();
+_st($1)._on_send_to_($ClassAdded(),"onClassAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($ClassRemoved(),"onClassRemoved:",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st($1)._on_send_to_($ClassMoved(),"onClassMoved:",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+_st($1)._on_send_to_($ClassRenamed(),"onClassRenamed:",self);
+$ctx1.sendIdx["on:send:to:"]=4;
+_st($1)._on_send_to_($ClassMigrated(),"onClassMigrated:",self);
+$ctx1.sendIdx["on:send:to:"]=5;
+$2=_st($1)._on_send_to_($ClassCommentChanged(),"onClassCommentChanged:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLClassesListWidget)})},
+args: [],
+source: "observeSystem\x0a\x09self model systemAnnouncer\x0a    \x09on: ClassAdded\x0a\x09\x09send: #onClassAdded:\x0a\x09\x09to: self;\x0a\x09\x09\x0a        on: ClassRemoved\x0a        send: #onClassRemoved:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: ClassMoved\x0a\x09\x09send: #onClassMoved:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: ClassRenamed\x0a\x09\x09send: #onClassRenamed:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: ClassMigrated\x0a\x09\x09send: #onClassMigrated:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: ClassCommentChanged\x0a        send: #onClassCommentChanged:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "systemAnnouncer", "model"],
+referencedClasses: ["ClassAdded", "ClassRemoved", "ClassMoved", "ClassRenamed", "ClassMigrated", "ClassCommentChanged"]
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+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,1)})}));
+if(! smalltalk.assert($1)){
+return self;
+};
+self._setItemsForSelectedPackage();
+self._refresh();
+$2=self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{anAnnouncement:anAnnouncement,class_:class_},globals.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 \x0a\x09\x09setItemsForSelectedPackage;\x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["theClass", "ifFalse:", "or:", "=", "package", "selectedPackage", "model", "includes:", "items", "setItemsForSelectedPackage", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassCommentChanged:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+class_=_st(anAnnouncement)._theClass();
+$1=_st(_st(class_)._package()).__eq(_st(self._model())._selectedPackage());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._refresh();
+$2=self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassCommentChanged:",{anAnnouncement:anAnnouncement,class_:class_},globals.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 \x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["theClass", "ifFalse:", "=", "package", "selectedPackage", "model", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassMigrated:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_,oldClass;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$4,$3,$2,$5;
+class_=_st(anAnnouncement)._theClass();
+oldClass=_st(anAnnouncement)._oldClass();
+$1=_st(self._items())._includes_(oldClass);
+if(! smalltalk.assert($1)){
+return self;
+};
+$4=self._model();
+$ctx1.sendIdx["model"]=1;
+$3=_st($4)._selectedClass();
+$2=_st($3).__eq(oldClass);
+if(smalltalk.assert($2)){
+_st(self._model())._selectedClass_(class_);
+};
+self._setItemsForSelectedPackage();
+self._refresh();
+$5=self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassMigrated:",{anAnnouncement:anAnnouncement,class_:class_,oldClass:oldClass},globals.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 \x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["theClass", "oldClass", "ifFalse:", "includes:", "items", "ifTrue:", "=", "selectedClass", "model", "selectedClass:", "setItemsForSelectedPackage", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassMoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_,oldPackage;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$5,$4,$2,$6,$8,$7,$1,$9,$10,$11;
+class_=_st(anAnnouncement)._theClass();
+oldPackage=_st(anAnnouncement)._oldPackage();
+$3=oldPackage;
+$5=self._model();
+$ctx1.sendIdx["model"]=1;
+$4=_st($5)._selectedPackage();
+$ctx1.sendIdx["selectedPackage"]=1;
+$2=_st($3).__eq($4);
+$ctx1.sendIdx["="]=1;
+$1=_st($2)._or_((function(){
+return smalltalk.withContext(function($ctx2) {
+$6=_st(class_)._package();
+$8=self._model();
+$ctx2.sendIdx["model"]=2;
+$7=_st($8)._selectedPackage();
+$ctx2.sendIdx["selectedPackage"]=2;
+return _st($6).__eq($7);
+$ctx2.sendIdx["="]=2;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+if(! smalltalk.assert($1)){
+return self;
+};
+$9=_st(oldPackage).__eq(_st(self._model())._selectedPackage());
+if(smalltalk.assert($9)){
+self._selectedItem_(nil);
+$10=self._selectItem_(nil);
+$10;
+};
+self._setItemsForSelectedPackage();
+self._refresh();
+$11=self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassMoved:",{anAnnouncement:anAnnouncement,class_:class_,oldPackage:oldPackage},globals.HLClassesListWidget)})},
+args: ["anAnnouncement"],
+source: "onClassMoved: anAnnouncement\x0a\x09| class oldPackage |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09oldPackage := anAnnouncement oldPackage.\x0a\x09\x0a\x09(oldPackage = self model selectedPackage or: [\x0a\x09\x09class package = self model selectedPackage ])\x0a\x09\x09\x09ifFalse: [ ^ self ].\x0a\x09\x0a\x09oldPackage = self model selectedPackage ifTrue: [ \x0a\x09\x09self \x0a\x09\x09\x09selectedItem: nil;\x0a\x09\x09\x09selectItem: nil ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self \x09\x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["theClass", "oldPackage", "ifFalse:", "or:", "=", "selectedPackage", "model", "package", "ifTrue:", "selectedItem:", "selectItem:", "setItemsForSelectedPackage", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassRemoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+class_=_st(anAnnouncement)._theClass();
+$1=_st(_st(class_)._package()).__eq(_st(self._model())._selectedPackage());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._selectItem_(nil);
+$2=self._selectedItem_(nil);
+self._setItemsForSelectedPackage();
+self._refresh();
+$3=self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassRemoved:",{anAnnouncement:anAnnouncement,class_:class_},globals.HLClassesListWidget)})},
+args: ["anAnnouncement"],
+source: "onClassRemoved: anAnnouncement\x0a\x09| class |\x0a\x09class := anAnnouncement theClass.\x0a\x0a\x09class package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a\x09self \x0a\x09\x09selectItem: nil;\x0a\x09\x09selectedItem: nil.\x0a    self setItemsForSelectedPackage.\x0a    self \x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["theClass", "ifFalse:", "=", "package", "selectedPackage", "model", "selectItem:", "selectedItem:", "setItemsForSelectedPackage", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassRenamed:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(_st(_st(anAnnouncement)._theClass())._package()).__eq(_st(self._model())._selectedPackage());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._setItemsForSelectedPackage();
+self._refresh();
+$2=self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassRenamed:",{anAnnouncement:anAnnouncement},globals.HLClassesListWidget)})},
+args: ["anAnnouncement"],
+source: "onClassRenamed: anAnnouncement\x0a\x09anAnnouncement theClass package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self \x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["ifFalse:", "=", "package", "theClass", "selectedPackage", "model", "setItemsForSelectedPackage", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var selectedClass;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$receiver;
+$1=_st(anAnnouncement)._item();
+$ctx1.sendIdx["item"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+selectedClass=_st(_st(anAnnouncement)._item())._theNonMetaClass();
+self._selectedItem_(selectedClass);
+$2=self._hasFocus();
+if(! smalltalk.assert($2)){
+self._activateItem_(selectedClass);
+$3=self._focus();
+$3;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement,selectedClass:selectedClass},globals.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:", "hasFocus", "activateItem:", "focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassesFocusRequested",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassesFocusRequested",{},globals.HLClassesListWidget)})},
+args: [],
+source: "onClassesFocusRequested\x0a\x09self focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectedItem_(nil);
+self._setItemsForSelectedPackage();
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageSelected:",{anAnnouncement:anAnnouncement},globals.HLClassesListWidget)})},
+args: ["anAnnouncement"],
+source: "onPackageSelected: anAnnouncement\x0a    self selectedItem: nil.\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
+messageSends: ["selectedItem:", "setItemsForSelectedPackage", "refresh"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowCommentToggled",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onShowCommentToggled",{},globals.HLClassesListWidget)})},
+args: [],
+source: "onShowCommentToggled\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowInstanceToggled",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onShowInstanceToggled",{},globals.HLClassesListWidget)})},
+args: [],
+source: "onShowInstanceToggled\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+var checkbox;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$6,$5,$7,$8,$9,$10,$2,$11,$13,$14,$12,$15;
+$1=_st(html)._div();
+_st($1)._class_("btn-group");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._button();
+$ctx2.sendIdx["button"]=1;
+$4=$3;
+$5=_st($String())._streamContents_((function(str){
+return smalltalk.withContext(function($ctx3) {
+_st(str)._nextPutAll_("btn");
+$ctx3.sendIdx["nextPutAll:"]=1;
+$6=self._showInstance();
+if(smalltalk.assert($6)){
+return _st(str)._nextPutAll_(" active");
+$ctx3.sendIdx["nextPutAll:"]=2;
+};
+}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2,2)})}));
+$ctx2.sendIdx["streamContents:"]=1;
+_st($4)._class_($5);
+$ctx2.sendIdx["class:"]=2;
+_st($3)._with_("Instance");
+$ctx2.sendIdx["with:"]=2;
+$7=_st($3)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._showInstance_(true);
+$ctx3.sendIdx["showInstance:"]=1;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+$ctx2.sendIdx["onClick:"]=1;
+$7;
+$8=_st(html)._button();
+_st($8)._class_(_st($String())._streamContents_((function(str){
+return smalltalk.withContext(function($ctx3) {
+_st(str)._nextPutAll_("btn");
+$ctx3.sendIdx["nextPutAll:"]=3;
+$9=self._showClass();
+if(smalltalk.assert($9)){
+return _st(str)._nextPutAll_(" active");
+};
+}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2,5)})})));
+$ctx2.sendIdx["class:"]=3;
+_st($8)._with_("Class");
+$ctx2.sendIdx["with:"]=3;
+$10=_st($8)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._showInstance_(false);
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,7)})}));
+$ctx2.sendIdx["onClick:"]=2;
+return $10;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+$11=_st(html)._label();
+_st($11)._class_("checkbox");
+$12=_st($11)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$13=_st(html)._input();
+_st($13)._type_("checkbox");
+$14=_st($13)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._toggleShowComment();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,9)})}));
+checkbox=$14;
+checkbox;
+return _st(html)._with_("Doc");
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,8)})}));
+$ctx1.sendIdx["with:"]=4;
+$15=self._showComment();
+if(smalltalk.assert($15)){
+_st(checkbox)._at_put_("checked","checked");
+};
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html,checkbox:checkbox},globals.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:", "button", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "onClick:", "showInstance:", "showClass", "label", "type:", "input", "toggleShowComment", "showComment", "at:put:"],
+referencedClasses: ["String"]
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItem:level:on:",
+protocol: 'rendering',
+fn: function (aClass,anInteger,html){
+var self=this;
+var li;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$5,$3;
+li=_st(html)._li();
+$1=_st(li)._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._data_put_("item",aClass);
+$2=li;
+_st($2)._class_(self._listCssClassForItem_(aClass));
+$ctx1.sendIdx["class:"]=1;
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(html)._a();
+_st($4)._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,2)})}));
+$5=_st($4)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._reactivateListItem_(_st(li)._asJQuery());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+return $5;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=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,4)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderItem:level:on:",{aClass:aClass,anInteger:anInteger,html:html,li:li},globals.HLClassesListWidget)})},
+args: ["aClass", "anInteger", "html"],
+source: "renderItem: aClass level: anInteger on: html\x0a\x09| li |\x0a    \x0a\x09li := html li.\x0a\x09li asJQuery data: 'item' put: aClass.\x0a    li\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 reactivateListItem: li asJQuery ] ].\x0a                    \x0a    (self getChildrenOf: aClass) do: [ :each |\x0a    \x09self renderItem: each level: anInteger + 1 on: html ]",
+messageSends: ["li", "data:put:", "asJQuery", "class:", "listCssClassForItem:", "with:", "a", "tag:", "cssClassForItem:", "renderItemLabel:level:on:", "onClick:", "reactivateListItem:", "do:", "getChildrenOf:", "renderItem:level:on:", "+"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItem:on:",
+protocol: 'rendering',
+fn: function (aClass,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLClassesListWidget.superclass.fn.prototype._renderItem_on_.apply(_st(self), [aClass,html]));
+$ctx1.supercall = false;
+_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,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderItem:on:",{aClass:aClass,html:html},globals.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:", "getChildrenOf:", "renderItem:level:on:"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:level:on:",
+protocol: 'rendering',
+fn: function (aClass,anInteger,html){
+var self=this;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(_st(html)._span())._asJQuery())._html_(_st($String())._streamContents_((function(str){
+return smalltalk.withContext(function($ctx2) {
+_st(anInteger)._timesRepeat_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(str)._nextPutAll_("    ");
+$ctx3.sendIdx["nextPutAll:"]=1;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+return _st(str)._nextPutAll_(_st(aClass)._name());
+}, function($ctx2) {$ctx2.fillBlock({str:str},$ctx1,1)})})));
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:level:on:",{aClass:aClass,anInteger:anInteger,html:html},globals.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:", "asJQuery", "span", "streamContents:", "timesRepeat:", "nextPutAll:", "name"],
+referencedClasses: ["String"]
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:on:",
+protocol: 'rendering',
+fn: function (aClass,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._renderItemLabel_level_on_(aClass,(0),html);
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aClass:aClass,html:html},globals.HLClassesListWidget)})},
+args: ["aClass", "html"],
+source: "renderItemLabel: aClass on: html\x0a\x09self renderItemLabel: aClass level: 0 on: html",
+messageSends: ["renderItemLabel:level:on:"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderListOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+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,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderListOn:",{html:html},globals.HLClassesListWidget)})},
+args: ["html"],
+source: "renderListOn: html\x0a\x09(self getRootClassesOf: self items)\x0a    \x09do: [ :each | self renderItem: each on: html ]",
+messageSends: ["do:", "getRootClassesOf:", "items", "renderItem:on:"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reselectItem:",
+protocol: 'actions',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._forceSelectedClass_(anItem);
+return self}, function($ctx1) {$ctx1.fill(self,"reselectItem:",{anItem:anItem},globals.HLClassesListWidget)})},
+args: ["anItem"],
+source: "reselectItem: anItem\x0a\x09self model forceSelectedClass: anItem",
+messageSends: ["forceSelectedClass:", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._selectedClass_(aClass);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aClass:aClass},globals.HLClassesListWidget)})},
+args: ["aClass"],
+source: "selectItem: aClass\x0a    self model selectedClass: aClass",
+messageSends: ["selectedClass:", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setItemsForPackage:",
+protocol: 'private',
+fn: function (aPackage){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+if(($receiver = aPackage) == null || $receiver.isNil){
+$1=[];
+} else {
+$1=_st(_st(_st(aPackage)._classes())._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._theNonMetaClass();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})})))._sort_((function(a,b){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(a)._name();
+$ctx2.sendIdx["name"]=1;
+return _st($2).__lt(_st(b)._name());
+}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,4)})}));
+};
+self._items_($1);
+return self}, function($ctx1) {$ctx1.fill(self,"setItemsForPackage:",{aPackage:aPackage},globals.HLClassesListWidget)})},
+args: ["aPackage"],
+source: "setItemsForPackage: aPackage\x0a\x09self items: (aPackage \x0a    \x09ifNil: [ #() ]\x0a  \x09\x09ifNotNil: [ (aPackage classes \x0a        \x09collect: [ :each | each theNonMetaClass ]) \x0a            \x09sort: [ :a :b | a name < b name ] ]).",
+messageSends: ["items:", "ifNil:ifNotNil:", "sort:", "collect:", "classes", "theNonMetaClass", "<", "name"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setItemsForSelectedPackage",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._setItemsForPackage_(_st(self._model())._selectedPackage());
+return self}, function($ctx1) {$ctx1.fill(self,"setItemsForSelectedPackage",{},globals.HLClassesListWidget)})},
+args: [],
+source: "setItemsForSelectedPackage\x0a\x09self setItemsForPackage: self model selectedPackage",
+messageSends: ["setItemsForPackage:", "selectedPackage", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showClass",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._showInstance())._not();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"showClass",{},globals.HLClassesListWidget)})},
+args: [],
+source: "showClass\x0a\x09^ self model showInstance not",
+messageSends: ["not", "showInstance", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showComment",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._showComment();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"showComment",{},globals.HLClassesListWidget)})},
+args: [],
+source: "showComment\x0a\x09^ self model showComment",
+messageSends: ["showComment", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showComment:",
+protocol: 'actions',
+fn: function (aBoolean){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._showComment_(aBoolean);
+return self}, function($ctx1) {$ctx1.fill(self,"showComment:",{aBoolean:aBoolean},globals.HLClassesListWidget)})},
+args: ["aBoolean"],
+source: "showComment: aBoolean\x0a\x09self model showComment: aBoolean",
+messageSends: ["showComment:", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showInstance",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._showInstance();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"showInstance",{},globals.HLClassesListWidget)})},
+args: [],
+source: "showInstance\x0a\x09^ self model showInstance",
+messageSends: ["showInstance", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showInstance:",
+protocol: 'actions',
+fn: function (aBoolean){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._showInstance_(aBoolean);
+return self}, function($ctx1) {$ctx1.fill(self,"showInstance:",{aBoolean:aBoolean},globals.HLClassesListWidget)})},
+args: ["aBoolean"],
+source: "showInstance: aBoolean\x0a\x09self model showInstance: aBoolean",
+messageSends: ["showInstance:", "model"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "toggleShowComment",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._showComment_(_st(self._showComment())._not());
+return self}, function($ctx1) {$ctx1.fill(self,"toggleShowComment",{},globals.HLClassesListWidget)})},
+args: [],
+source: "toggleShowComment\x0a\x09self model showComment: self showComment not",
+messageSends: ["showComment:", "model", "not", "showComment"],
+referencedClasses: []
+}),
+globals.HLClassesListWidget);
+
+
+
+smalltalk.addClass('HLDocumentationWidget', globals.HLFocusableWidget, ['model'], 'Helios-Browser');
+globals.HLDocumentationWidget.comment="I render the documentation for the selected class";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultDocumentation",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return "No documentation is available for this class.";
+},
+args: [],
+source: "defaultDocumentation\x0a\x09^ 'No documentation is available for this class.'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultHead",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return "No class selected";
+},
+args: [],
+source: "defaultHead\x0a\x09^ 'No class selected'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "documentation",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self._selectedItem();
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+var item;
+item=$receiver;
+$1=_st(_st(item)._comment())._ifEmpty_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._defaultDocumentation();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"documentation",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "documentation\x0a\x09^ self selectedItem \x0a\x09\x09ifNil: [ '' ]\x0a\x09\x09ifNotNil: [ :item | item comment ifEmpty: [ self defaultDocumentation ] ]",
+messageSends: ["ifNil:ifNotNil:", "selectedItem", "ifEmpty:", "comment", "defaultDocumentation"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "editDocumentation",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._editComment();
+return self}, function($ctx1) {$ctx1.fill(self,"editDocumentation",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "editDocumentation\x0a\x09self model editComment",
+messageSends: ["editComment", "model"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "head",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self._selectedItem();
+if(($receiver = $2) == null || $receiver.isNil){
+$1=self._defaultHead();
+} else {
+var item;
+item=$receiver;
+$1=_st(item)._name();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"head",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "head\x0a\x09^ self selectedItem \x0a\x09\x09ifNil: [ self defaultHead ]\x0a\x09\x09ifNotNil: [ :item | item name ]",
+messageSends: ["ifNil:ifNotNil:", "selectedItem", "defaultHead", "name"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@model"];
+return $1;
+},
+args: [],
+source: "model\x0a\x09^ model",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self["@model"]=aModel;
+self._observeSystem();
+$1=self._observeModel();
+return self}, function($ctx1) {$ctx1.fill(self,"model:",{aModel:aModel},globals.HLDocumentationWidget)})},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel.\x0a\x09self \x0a\x09\x09observeSystem;\x0a\x09\x09observeModel",
+messageSends: ["observeSystem", "observeModel"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+function $HLEditComment(){return globals.HLEditComment||(typeof HLEditComment=="undefined"?nil:HLEditComment)}
+function $HLDocumentationFocusRequested(){return globals.HLDocumentationFocusRequested||(typeof HLDocumentationFocusRequested=="undefined"?nil:HLDocumentationFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLClassSelected(),"onClassSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($HLEditComment(),"onEditDocumentation",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+$2=_st($1)._on_send_to_($HLDocumentationFocusRequested(),"onDocumentationFocusRequested",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer \x0a\x09\x09on: HLClassSelected\x0a\x09\x09send: #onClassSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLEditComment\x0a\x09\x09send: #onEditDocumentation\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLDocumentationFocusRequested\x0a\x09\x09send: #onDocumentationFocusRequested\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLClassSelected", "HLEditComment", "HLDocumentationFocusRequested"]
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $ClassCommentChanged(){return globals.ClassCommentChanged||(typeof ClassCommentChanged=="undefined"?nil:ClassCommentChanged)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._model())._systemAnnouncer())._on_send_to_($ClassCommentChanged(),"onClassCommentChanged:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "observeSystem\x0a\x09self model systemAnnouncer \x0a\x09\x09on: ClassCommentChanged\x0a\x09\x09send: #onClassCommentChanged:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "systemAnnouncer", "model"],
+referencedClasses: ["ClassCommentChanged"]
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassCommentChanged:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$receiver;
+$2=self._model();
+$ctx1.sendIdx["model"]=1;
+$1=_st($2)._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+$3=_st(_st(anAnnouncement)._theClass()).__eq(_st(_st(self._model())._selectedClass())._theNonMetaClass());
+if(smalltalk.assert($3)){
+self._refresh();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onClassCommentChanged:",{anAnnouncement:anAnnouncement},globals.HLDocumentationWidget)})},
+args: ["anAnnouncement"],
+source: "onClassCommentChanged: anAnnouncement\x0a\x09self model selectedClass ifNil: [ ^ self ].\x0a\x09\x0a\x09anAnnouncement theClass = self model selectedClass theNonMetaClass\x0a\x09\x09ifTrue: [ self refresh ]",
+messageSends: ["ifNil:", "selectedClass", "model", "ifTrue:", "=", "theClass", "theNonMetaClass", "refresh"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement},globals.HLDocumentationWidget)})},
+args: ["anAnnouncement"],
+source: "onClassSelected: anAnnouncement\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onDocumentationFocusRequested",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onDocumentationFocusRequested",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "onDocumentationFocusRequested\x0a\x09self focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onEditDocumentation",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $5,$4,$3,$2,$1;
+$5=self._model();
+$ctx1.sendIdx["model"]=1;
+$4=_st($5)._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+$3=_st($4)._theNonMetaClass();
+$ctx1.sendIdx["theNonMetaClass"]=1;
+$2=_st($3)._name();
+$1=_st($2).__comma(" comment");
+self._request_value_do_($1,_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,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"onEditDocumentation",{},globals.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 ]",
+messageSends: ["request:value:do:", ",", "name", "theNonMetaClass", "selectedClass", "model", "comment", "setClassComment:"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2;
+$1=_st(html)._div();
+_st($1)._class_("doc");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._renderHeadOn_(html);
+$3=self._renderDocOn_(html);
+return $3;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.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 ]",
+messageSends: ["class:", "div", "with:", "renderHeadOn:", "renderDocOn:"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderDocOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $Showdown(){return globals.Showdown||(typeof Showdown=="undefined"?nil:Showdown)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$5,$3,$6,$7,$receiver;
+$1=self._selectedItem();
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+self._renderInheritanceOn_(html);
+$2=_st(html)._h1();
+_st($2)._with_("Overview");
+$ctx1.sendIdx["with:"]=1;
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(html)._button();
+_st($4)._class_("button default");
+$ctx2.sendIdx["class:"]=1;
+_st($4)._with_("Edit");
+$5=_st($4)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._editDocumentation();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+return $5;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$ctx1.sendIdx["with:"]=2;
+$3;
+$6=_st(html)._div();
+_st($6)._class_("markdown");
+$7=_st($6)._asJQuery();
+_st($7)._html_(_st(_st(_st($Showdown())._at_("converter"))._new())._makeHtml_(self._documentation()));
+};
+return self}, function($ctx1) {$ctx1.fill(self,"renderDocOn:",{html:html},globals.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:", "selectedItem", "renderInheritanceOn:", "with:", "h1", "class:", "button", "onClick:", "editDocumentation", "html:", "div", "asJQuery", "makeHtml:", "new", "at:", "documentation"],
+referencedClasses: ["Showdown"]
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderHeadOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("head");
+$2=_st($1)._with_(self._head());
+return self}, function($ctx1) {$ctx1.fill(self,"renderHeadOn:",{html:html},globals.HLDocumentationWidget)})},
+args: ["html"],
+source: "renderHeadOn: html\x0a\x09html div \x0a\x09\x09class: 'head';\x0a\x09\x09with: self head",
+messageSends: ["class:", "div", "with:", "head"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderInheritanceOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$4,$3,$5,$6,$9,$8,$7,$10,$2,$receiver;
+$1=_st(html)._div();
+_st($1)._class_("inheritance");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+_st(html)._with_("Subclass of ");
+$ctx2.sendIdx["with:"]=2;
+$4=self._selectedItem();
+$ctx2.sendIdx["selectedItem"]=1;
+$3=_st($4)._superclass();
+$ctx2.sendIdx["superclass"]=1;
+if(($receiver = $3) == null || $receiver.isNil){
+return _st(_st(html)._em())._with_("nil");
+$ctx2.sendIdx["with:"]=3;
+} else {
+$5=_st(html)._a();
+$6=$5;
+$9=self._selectedItem();
+$ctx2.sendIdx["selectedItem"]=2;
+$8=_st($9)._superclass();
+$ctx2.sendIdx["superclass"]=2;
+$7=_st($8)._name();
+_st($6)._with_($7);
+$10=_st($5)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._selectClass_(_st(self._selectedItem())._superclass());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+return $10;
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderInheritanceOn:",{html:html},globals.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:", "superclass", "selectedItem", "em", "a", "name", "onClick:", "selectClass:"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectClass:",
+protocol: 'actions',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._selectedClass_(aClass);
+return self}, function($ctx1) {$ctx1.fill(self,"selectClass:",{aClass:aClass},globals.HLDocumentationWidget)})},
+args: ["aClass"],
+source: "selectClass: aClass\x0a\x09self model selectedClass: aClass",
+messageSends: ["selectedClass:", "model"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedItem",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=_st(self._model())._selectedClass();
+if(($receiver = $2) == null || $receiver.isNil){
+$1=$2;
+} else {
+var class_;
+class_=$receiver;
+$1=_st(class_)._theNonMetaClass();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedItem",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "selectedItem\x0a\x09^ self model selectedClass ifNotNil: [ :class | class theNonMetaClass ]",
+messageSends: ["ifNotNil:", "selectedClass", "model", "theNonMetaClass"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setClassComment:",
+protocol: 'reactions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._setClassComment_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"setClassComment:",{aString:aString},globals.HLDocumentationWidget)})},
+args: ["aString"],
+source: "setClassComment: aString\x0a\x09self model setClassComment: aString",
+messageSends: ["setClassComment:", "model"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLDocumentationWidget.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+_st(_st(self._model())._announcer())._unregister_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLDocumentationWidget)})},
+args: [],
+source: "unregister\x0a\x09super unregister.\x0a\x09self model announcer unregister: self",
+messageSends: ["unregister", "unregister:", "announcer", "model"],
+referencedClasses: []
+}),
+globals.HLDocumentationWidget);
+
+
+
+smalltalk.addClass('HLMethodsListWidget', globals.HLToolListWidget, ['selectorsCache'], 'Helios-Browser');
+globals.HLMethodsListWidget.comment="I render a list of methods for the selected protocol.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "allProtocol",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._allProtocol();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"allProtocol",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "allProtocol\x0a\x09^ self model allProtocol",
+messageSends: ["allProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClassForItem:",
+protocol: 'accessing',
+fn: function (aSelector){
+var self=this;
+var override,overriden,method;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1;
+method=self._methodForSelector_(aSelector);
+override=self._isOverride_(method);
+overriden=self._isOverridden_(method);
+$2=override;
+if(smalltalk.assert($2)){
+$3=overriden;
+if(smalltalk.assert($3)){
+$1="override-overridden";
+} else {
+$1="override";
+};
+} else {
+$4=overriden;
+if(smalltalk.assert($4)){
+$1="overridden";
+} else {
+$1="";
+};
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClassForItem:",{aSelector:aSelector,override:override,overriden:overriden,method:method},globals.HLMethodsListWidget)})},
+args: ["aSelector"],
+source: "cssClassForItem: aSelector\x0a\x09| override overriden method |\x0a    \x0a    method := self methodForSelector: aSelector.\x0a    override := self isOverride: method.\x0a    overriden := self isOverridden: method.\x0a    \x0a\x09^ override\x0a    \x09ifTrue: [ overriden\x0a\x09\x09\x09ifTrue: [ 'override-overridden' ]\x0a\x09\x09\x09ifFalse: [ 'override' ] ]\x0a\x09\x09ifFalse: [\x0a\x09\x09\x09overriden\x0a\x09\x09\x09ifTrue: [ 'overridden' ]\x0a\x09\x09\x09ifFalse: [ '' ] ]",
+messageSends: ["methodForSelector:", "isOverride:", "isOverridden:", "ifTrue:ifFalse:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+($ctx1.supercall = true, globals.HLMethodsListWidget.superclass.fn.prototype._focus.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=self._selectedItem();
+if(($receiver = $1) == null || $receiver.isNil){
+_st(self._model())._showMethodTemplate();
+} else {
+$1;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "focus\x0a\x09super focus.\x0a\x09\x0a\x09self selectedItem ifNil: [\x0a\x09\x09self model showMethodTemplate ]",
+messageSends: ["focus", "ifNil:", "selectedItem", "showMethodTemplate", "model"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isOverridden:",
+protocol: 'testing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._selectorsCache())._isOverridden_(aMethod);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isOverridden:",{aMethod:aMethod},globals.HLMethodsListWidget)})},
+args: ["aMethod"],
+source: "isOverridden: aMethod\x0a   ^ self selectorsCache isOverridden: aMethod",
+messageSends: ["isOverridden:", "selectorsCache"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isOverride:",
+protocol: 'testing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._selectorsCache())._isOverride_(aMethod);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isOverride:",{aMethod:aMethod},globals.HLMethodsListWidget)})},
+args: ["aMethod"],
+source: "isOverride: aMethod\x0a   ^ self selectorsCache isOverride: aMethod",
+messageSends: ["isOverride:", "selectorsCache"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Methods";
+},
+args: [],
+source: "label\x0a\x09^ 'Methods'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodForSelector:",
+protocol: 'accessing',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(self._model())._selectedClass())._methodDictionary())._at_(aSelector);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"methodForSelector:",{aSelector:aSelector},globals.HLMethodsListWidget)})},
+args: ["aSelector"],
+source: "methodForSelector: aSelector\x0a\x09^ self model selectedClass\x0a    \x09methodDictionary at: aSelector",
+messageSends: ["at:", "methodDictionary", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodsInProtocol:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$5,$7,$6,$4,$receiver;
+$2=self._model();
+$ctx1.sendIdx["model"]=1;
+$1=_st($2)._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$3=[];
+return $3;
+} else {
+$1;
+};
+$5=_st(aString).__eq(self._allProtocol());
+if(smalltalk.assert($5)){
+$7=self._model();
+$ctx1.sendIdx["model"]=2;
+$6=_st($7)._selectedClass();
+$ctx1.sendIdx["selectedClass"]=2;
+$4=_st($6)._methods();
+} else {
+$4=_st(_st(self._model())._selectedClass())._methodsInProtocol_(aString);
+};
+return $4;
+}, function($ctx1) {$ctx1.fill(self,"methodsInProtocol:",{aString:aString},globals.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:", "=", "allProtocol", "methods", "methodsInProtocol:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLProtocolSelected(){return globals.HLProtocolSelected||(typeof HLProtocolSelected=="undefined"?nil:HLProtocolSelected)}
+function $HLShowInstanceToggled(){return globals.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
+function $HLMethodSelected(){return globals.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
+function $HLMethodsFocusRequested(){return globals.HLMethodsFocusRequested||(typeof HLMethodsFocusRequested=="undefined"?nil:HLMethodsFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLProtocolSelected(),"onProtocolSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($HLShowInstanceToggled(),"onShowInstanceToggled",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st($1)._on_send_to_($HLMethodSelected(),"onMethodSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+$2=_st($1)._on_send_to_($HLMethodsFocusRequested(),"onMethodsFocusRequested",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer \x0a\x09\x09on: HLProtocolSelected \x0a\x09\x09send: #onProtocolSelected: \x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLShowInstanceToggled \x0a\x09\x09send: #onShowInstanceToggled\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLMethodSelected \x0a\x09\x09send: #onMethodSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLMethodsFocusRequested \x0a\x09\x09send: #onMethodsFocusRequested\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLProtocolSelected", "HLShowInstanceToggled", "HLMethodSelected", "HLMethodsFocusRequested"]
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $ProtocolAdded(){return globals.ProtocolAdded||(typeof ProtocolAdded=="undefined"?nil:ProtocolAdded)}
+function $ProtocolRemoved(){return globals.ProtocolRemoved||(typeof ProtocolRemoved=="undefined"?nil:ProtocolRemoved)}
+function $MethodAdded(){return globals.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)}
+function $MethodRemoved(){return globals.MethodRemoved||(typeof MethodRemoved=="undefined"?nil:MethodRemoved)}
+function $MethodMoved(){return globals.MethodMoved||(typeof MethodMoved=="undefined"?nil:MethodMoved)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._systemAnnouncer();
+_st($1)._on_send_to_($ProtocolAdded(),"onProtocolAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($ProtocolRemoved(),"onProtocolRemoved:",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st($1)._on_send_to_($MethodAdded(),"onMethodAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+_st($1)._on_send_to_($MethodRemoved(),"onMethodRemoved:",self);
+$ctx1.sendIdx["on:send:to:"]=4;
+$2=_st($1)._on_send_to_($MethodMoved(),"onMethodMoved:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "observeSystem\x0a\x09self model systemAnnouncer \x0a    \x09on: ProtocolAdded\x0a        send: #onProtocolAdded:\x0a\x09\x09to: self;\x0a    \x09\x0a\x09\x09on: ProtocolRemoved\x0a        send: #onProtocolRemoved:\x0a\x09\x09to: self;\x0a\x09\x09\x0a    \x09on: MethodAdded \x0a        send: #onMethodAdded:\x0a\x09\x09to: self;\x0a\x09\x09\x0a        on: MethodRemoved \x0a        send: #onMethodRemoved:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: MethodMoved \x0a        send: #onMethodMoved:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "systemAnnouncer", "model"],
+referencedClasses: ["ProtocolAdded", "ProtocolRemoved", "MethodAdded", "MethodRemoved", "MethodMoved"]
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass()).__eq(_st(_st(anAnnouncement)._method())._methodClass());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._setItemsForSelectedProtocol();
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodAdded:",{anAnnouncement:anAnnouncement},globals.HLMethodsListWidget)})},
+args: ["anAnnouncement"],
+source: "onMethodAdded: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement method methodClass ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedProtocol.\x0a    self refresh",
+messageSends: ["ifFalse:", "=", "selectedClass", "model", "methodClass", "method", "setItemsForSelectedProtocol", "refresh"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodMoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1,$6,$5,$4,$7;
+$3=self._model();
+$ctx1.sendIdx["model"]=1;
+$2=_st($3)._selectedMethod();
+$1=_st($2).__eq(_st(anAnnouncement)._method());
+$ctx1.sendIdx["="]=1;
+if(! smalltalk.assert($1)){
+return self;
+};
+$6=self._model();
+$ctx1.sendIdx["model"]=2;
+$5=_st($6)._selectedProtocol();
+$4=_st($5).__eq(_st(self._model())._allProtocol());
+if(! smalltalk.assert($4)){
+self._selectedItem_(nil);
+self._selectItem_(nil);
+self._setItemsForSelectedProtocol();
+$7=self._refresh();
+$7;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodMoved:",{anAnnouncement:anAnnouncement},globals.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:", "=", "selectedMethod", "model", "method", "selectedProtocol", "allProtocol", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodRemoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var method;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$5,$6,$receiver;
+var $early={};
+try {
+method=_st(anAnnouncement)._method();
+_st(self._items())._detect_ifNone_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(method)._selector();
+$ctx2.sendIdx["selector"]=1;
+return _st(each).__eq($1);
+$ctx2.sendIdx["="]=1;
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){
+throw $early=[self];
+}));
+$2=self._selectedItem();
+$ctx1.sendIdx["selectedItem"]=1;
+if(($receiver = $2) == null || $receiver.isNil){
+$2;
+} else {
+$4=_st(_st(method)._methodClass()).__eq(_st(self._model())._selectedClass());
+$ctx1.sendIdx["="]=2;
+$3=_st($4)._and_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(method)._selector()).__eq(self._selectedItem());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)})}));
+if(smalltalk.assert($3)){
+self._selectedItem_(nil);
+$5=self._selectItem_(nil);
+$5;
+};
+};
+self._setItemsForSelectedProtocol();
+self._refresh();
+$6=self._focus();
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"onMethodRemoved:",{anAnnouncement:anAnnouncement,method:method},globals.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 \x0a\x09\x09refresh;\x0a\x09\x09focus",
+messageSends: ["method", "detect:ifNone:", "items", "=", "selector", "ifNotNil:", "selectedItem", "ifTrue:", "and:", "methodClass", "selectedClass", "model", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var selector,method;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+method=_st(anAnnouncement)._item();
+$1=_st(method)._isCompiledMethod();
+if(smalltalk.assert($1)){
+selector=_st(method)._selector();
+} else {
+selector=nil;
+};
+self._selectedItem_(selector);
+$2=self._activateItem_(selector);
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{anAnnouncement:anAnnouncement,selector:selector,method:method},globals.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:", "isCompiledMethod", "selector", "selectedItem:", "activateItem:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodsFocusRequested",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodsFocusRequested",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "onMethodsFocusRequested\x0a\x09self focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass()).__eq(_st(anAnnouncement)._theClass());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._setItemsForSelectedProtocol();
+self._refresh();
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolAdded:",{anAnnouncement:anAnnouncement},globals.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:", "=", "selectedClass", "model", "theClass", "setItemsForSelectedProtocol", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolRemoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass()).__eq(_st(anAnnouncement)._theClass());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._setItemsForSelectedProtocol();
+self._refresh();
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolRemoved:",{anAnnouncement:anAnnouncement},globals.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:", "=", "selectedClass", "model", "theClass", "setItemsForSelectedProtocol", "refresh", "focus"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectedItem_(nil);
+self._setItemsForSelectedProtocol();
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolSelected:",{anAnnouncement:anAnnouncement},globals.HLMethodsListWidget)})},
+args: ["anAnnouncement"],
+source: "onProtocolSelected: anAnnouncement\x0a    self selectedItem: nil.\x0a    \x0a\x09self setItemsForSelectedProtocol.\x0a    self refresh",
+messageSends: ["selectedItem:", "setItemsForSelectedProtocol", "refresh"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowInstanceToggled",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._onProtocolSelected_(nil);
+return self}, function($ctx1) {$ctx1.fill(self,"onShowInstanceToggled",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "onShowInstanceToggled\x0a\x09self onProtocolSelected: nil",
+messageSends: ["onProtocolSelected:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "overrideSelectors",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Set(){return globals.Set||(typeof Set=="undefined"?nil:Set)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$1=_st(self._selectorsCache())._at_ifAbsentPut_("override",(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(_st(self._model())._selectedClass())._allSuperclasses())._inject_into_(_st($Set())._new(),(function(acc,each){
+return smalltalk.withContext(function($ctx3) {
+_st(acc)._addAll_(_st(each)._selectors());
+$2=_st(acc)._yourself();
+return $2;
+}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"overrideSelectors",{},globals.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:", "selectorsCache", "inject:into:", "allSuperclasses", "selectedClass", "model", "new", "addAll:", "selectors", "yourself"],
+referencedClasses: ["Set"]
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "overridenSelectors",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Set(){return globals.Set||(typeof Set=="undefined"?nil:Set)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$1=_st(self._selectorsCache())._at_ifAbsentPut_("overriden",(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(_st(self._model())._selectedClass())._allSubclasses())._inject_into_(_st($Set())._new(),(function(acc,each){
+return smalltalk.withContext(function($ctx3) {
+_st(acc)._addAll_(_st(each)._selectors());
+$2=_st(acc)._yourself();
+return $2;
+}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"overridenSelectors",{},globals.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:", "selectorsCache", "inject:into:", "allSubclasses", "selectedClass", "model", "new", "addAll:", "selectors", "yourself"],
+referencedClasses: ["Set"]
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+$1=_st(self._model())._showInstance();
+if(smalltalk.assert($1)){
+($ctx1.supercall = true, globals.HLMethodsListWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+} else {
+$2=_st(html)._div();
+_st($2)._class_("class_side");
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLMethodsListWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx2.supercall = false;
+$ctx2.sendIdx["renderContentOn:"]=1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$3;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.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:", "showInstance", "model", "class:", "div", "with:", "renderContentOn:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:on:",
+protocol: 'rendering',
+fn: function (aSelector,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(html)._with_(aSelector);
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aSelector:aSelector,html:html},globals.HLMethodsListWidget)})},
+args: ["aSelector", "html"],
+source: "renderItemLabel: aSelector on: html\x0a\x09html with: aSelector",
+messageSends: ["with:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reselectItem:",
+protocol: 'actions',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._forceSelectedMethod_(self._methodForSelector_(aSelector));
+return self}, function($ctx1) {$ctx1.fill(self,"reselectItem:",{aSelector:aSelector},globals.HLMethodsListWidget)})},
+args: ["aSelector"],
+source: "reselectItem: aSelector\x0a\x09self model forceSelectedMethod: (self methodForSelector: aSelector)",
+messageSends: ["forceSelectedMethod:", "model", "methodForSelector:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+if(($receiver = aSelector) == null || $receiver.isNil){
+$2=self._model();
+$ctx1.sendIdx["model"]=1;
+$1=_st($2)._selectedMethod_(nil);
+$ctx1.sendIdx["selectedMethod:"]=1;
+return $1;
+} else {
+aSelector;
+};
+_st(self._model())._selectedMethod_(self._methodForSelector_(aSelector));
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aSelector:aSelector},globals.HLMethodsListWidget)})},
+args: ["aSelector"],
+source: "selectItem: aSelector\x0a\x09aSelector ifNil: [ ^ self model selectedMethod: nil ].\x0a\x0a   \x09self model selectedMethod: (self methodForSelector: aSelector)",
+messageSends: ["ifNil:", "selectedMethod:", "model", "methodForSelector:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectorsCache",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._selectorsCache();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectorsCache",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "selectorsCache\x0a\x09^ self class selectorsCache",
+messageSends: ["selectorsCache", "class"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectorsInProtocol:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+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,1)})})))._sorted();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectorsInProtocol:",{aString:aString},globals.HLMethodsListWidget)})},
+args: ["aString"],
+source: "selectorsInProtocol: aString\x0a\x09^ ((self methodsInProtocol: aString)\x0a    \x09collect: [ :each | each selector ]) sorted",
+messageSends: ["sorted", "collect:", "methodsInProtocol:", "selector"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setItemsForProtocol:",
+protocol: 'private',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+if(($receiver = aString) == null || $receiver.isNil){
+$2=[];
+} else {
+$2=self._selectorsInProtocol_(aString);
+};
+$1=self._items_($2);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"setItemsForProtocol:",{aString:aString},globals.HLMethodsListWidget)})},
+args: ["aString"],
+source: "setItemsForProtocol: aString\x0a\x09^ self items: (aString\x0a    \x09ifNil: [ #() ]\x0a      \x09ifNotNil: [ self selectorsInProtocol: aString ])",
+messageSends: ["items:", "ifNil:ifNotNil:", "selectorsInProtocol:"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setItemsForSelectedProtocol",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._setItemsForProtocol_(_st(self._model())._selectedProtocol());
+return self}, function($ctx1) {$ctx1.fill(self,"setItemsForSelectedProtocol",{},globals.HLMethodsListWidget)})},
+args: [],
+source: "setItemsForSelectedProtocol\x0a\x09self setItemsForProtocol: self model selectedProtocol",
+messageSends: ["setItemsForProtocol:", "selectedProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLMethodsListWidget);
+
+
+globals.HLMethodsListWidget.klass.iVarNames = ['selectorsCache'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectorsCache",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLSelectorsCache(){return globals.HLSelectorsCache||(typeof HLSelectorsCache=="undefined"?nil:HLSelectorsCache)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLSelectorsCache())._current();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectorsCache",{},globals.HLMethodsListWidget.klass)})},
+args: [],
+source: "selectorsCache\x0a\x09^ HLSelectorsCache current",
+messageSends: ["current"],
+referencedClasses: ["HLSelectorsCache"]
+}),
+globals.HLMethodsListWidget.klass);
+
+
+smalltalk.addClass('HLPackagesListWidget', globals.HLToolListWidget, [], 'Helios-Browser');
+globals.HLPackagesListWidget.comment="I render a list of the system packages.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClassForItem:",
+protocol: 'accessing',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=_st(anItem)._isDirty();
+if(smalltalk.assert($2)){
+$1="package_dirty";
+} else {
+$1="package";
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClassForItem:",{anItem:anItem},globals.HLPackagesListWidget)})},
+args: ["anItem"],
+source: "cssClassForItem: anItem\x09\x0a\x09^ anItem isDirty \x0a\x09\x09ifTrue: [ 'package_dirty' ]\x0a\x09\x09ifFalse: [ 'package' ]",
+messageSends: ["ifTrue:ifFalse:", "isDirty"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusClassesListWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLClassesListFocus(){return globals.HLClassesListFocus||(typeof HLClassesListFocus=="undefined"?nil:HLClassesListFocus)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._model())._announcer())._announce_(_st($HLClassesListFocus())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"focusClassesListWidget",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "focusClassesListWidget\x0a\x09self model announcer announce: HLClassesListFocus new",
+messageSends: ["announce:", "announcer", "model", "new"],
+referencedClasses: ["HLClassesListFocus"]
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeItems",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+self["@items"]=_st(_st(self._model())._packages())._sort_((function(a,b){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(a)._name();
+$ctx2.sendIdx["name"]=1;
+return _st($2).__lt(_st(b)._name());
+}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,1)})}));
+$1=self["@items"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"initializeItems",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "initializeItems\x0a\x09^ items := self model packages \x0a\x09\x09sort: [ :a :b | a name < b name ]",
+messageSends: ["sort:", "packages", "model", "<", "name"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "items",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@items"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=self._initializeItems();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"items",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "items\x0a\x09^ items ifNil: [ self initializeItems ]",
+messageSends: ["ifNil:", "initializeItems"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Packages";
+},
+args: [],
+source: "label\x0a\x09^ 'Packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+function $HLPackagesFocusRequested(){return globals.HLPackagesFocusRequested||(typeof HLPackagesFocusRequested=="undefined"?nil:HLPackagesFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLPackageSelected(),"onPackageSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+$2=_st($1)._on_send_to_($HLPackagesFocusRequested(),"onPackagesFocusRequested",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "observeModel\x0a    self model announcer \x0a\x09\x09on: HLPackageSelected\x0a\x09\x09send: #onPackageSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLPackagesFocusRequested \x0a\x09\x09send: #onPackagesFocusRequested\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLPackageSelected", "HLPackagesFocusRequested"]
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $ClassAdded(){return globals.ClassAdded||(typeof ClassAdded=="undefined"?nil:ClassAdded)}
+function $PackageAdded(){return globals.PackageAdded||(typeof PackageAdded=="undefined"?nil:PackageAdded)}
+function $PackageClean(){return globals.PackageClean||(typeof PackageClean=="undefined"?nil:PackageClean)}
+function $PackageDirty(){return globals.PackageDirty||(typeof PackageDirty=="undefined"?nil:PackageDirty)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$4,$3,$6,$5;
+$2=self._model();
+$ctx1.sendIdx["model"]=1;
+$1=_st($2)._systemAnnouncer();
+$ctx1.sendIdx["systemAnnouncer"]=1;
+_st($1)._on_send_to_($ClassAdded(),"onClassAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+$4=self._model();
+$ctx1.sendIdx["model"]=2;
+$3=_st($4)._systemAnnouncer();
+$ctx1.sendIdx["systemAnnouncer"]=2;
+_st($3)._on_send_to_($PackageAdded(),"onPackageAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+$6=self._model();
+$ctx1.sendIdx["model"]=3;
+$5=_st($6)._systemAnnouncer();
+$ctx1.sendIdx["systemAnnouncer"]=3;
+_st($5)._on_send_to_($PackageClean(),"onPackageStateChanged",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+_st(_st(self._model())._systemAnnouncer())._on_send_to_($PackageDirty(),"onPackageStateChanged",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "observeSystem\x0a    self model systemAnnouncer \x0a\x09\x09on: ClassAdded \x0a\x09\x09send: #onClassAdded:\x0a\x09\x09to: self.\x0a\x09\x09\x0a\x09self model systemAnnouncer\x0a\x09\x09on: PackageAdded\x0a\x09\x09send: #onPackageAdded:\x0a\x09\x09to: self.\x0a\x09\x09\x0a\x09self model systemAnnouncer\x0a\x09\x09on: PackageClean\x0a\x09\x09send: #onPackageStateChanged\x0a\x09\x09to: self.\x0a\x09\x09\x0a\x09self model systemAnnouncer\x0a\x09\x09on: PackageDirty\x0a\x09\x09send: #onPackageStateChanged\x0a\x09\x09to: self.\x0a\x09",
+messageSends: ["on:send:to:", "systemAnnouncer", "model"],
+referencedClasses: ["ClassAdded", "PackageAdded", "PackageClean", "PackageDirty"]
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._items())._includes_(_st(_st(anAnnouncement)._theClass())._package());
+if(! smalltalk.assert($1)){
+self._initializeItems();
+$2=self._refresh();
+$2;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{anAnnouncement:anAnnouncement},globals.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:", "includes:", "items", "package", "theClass", "initializeItems", "refresh"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._initializeItems();
+$1=self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageAdded:",{anAnnouncement:anAnnouncement},globals.HLPackagesListWidget)})},
+args: ["anAnnouncement"],
+source: "onPackageAdded: anAnnouncement\x0a\x09self \x0a\x09\x09initializeItems;\x0a\x09\x09refresh",
+messageSends: ["initializeItems", "refresh"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var package_;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+package_=_st(anAnnouncement)._item();
+self._selectedItem_(package_);
+$1=self._hasFocus();
+if(! smalltalk.assert($1)){
+self._activateItem_(package_);
+$2=self._focus();
+$2;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageSelected:",{anAnnouncement:anAnnouncement,package_:package_},globals.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:", "hasFocus", "activateItem:", "focus"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageStateChanged",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageStateChanged",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "onPackageStateChanged\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackagesFocusRequested",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onPackagesFocusRequested",{},globals.HLPackagesListWidget)})},
+args: [],
+source: "onPackagesFocusRequested\x0a\x09self focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:on:",
+protocol: 'rendering',
+fn: function (aPackage,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(html)._with_(_st(aPackage)._name());
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aPackage:aPackage,html:html},globals.HLPackagesListWidget)})},
+args: ["aPackage", "html"],
+source: "renderItemLabel: aPackage on: html\x0a\x09html with: aPackage name",
+messageSends: ["with:", "name"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reselectItem:",
+protocol: 'actions',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._forceSelectedPackage_(anItem);
+return self}, function($ctx1) {$ctx1.fill(self,"reselectItem:",{anItem:anItem},globals.HLPackagesListWidget)})},
+args: ["anItem"],
+source: "reselectItem: anItem\x0a\x09self model forceSelectedPackage: anItem",
+messageSends: ["forceSelectedPackage:", "model"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aPackage){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLPackagesListWidget.superclass.fn.prototype._selectItem_.apply(_st(self), [aPackage]));
+$ctx1.supercall = false;
+_st(self._model())._selectedPackage_(aPackage);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aPackage:aPackage},globals.HLPackagesListWidget)})},
+args: ["aPackage"],
+source: "selectItem: aPackage\x0a\x09super selectItem: aPackage.\x0a\x09self model selectedPackage: aPackage",
+messageSends: ["selectItem:", "selectedPackage:", "model"],
+referencedClasses: []
+}),
+globals.HLPackagesListWidget);
+
+
+
+smalltalk.addClass('HLProtocolsListWidget', globals.HLToolListWidget, [], 'Helios-Browser');
+globals.HLProtocolsListWidget.comment="I render a list of protocols for the selected class.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "allProtocol",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._allProtocol();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"allProtocol",{},globals.HLProtocolsListWidget)})},
+args: [],
+source: "allProtocol\x0a\x09^ self model allProtocol",
+messageSends: ["allProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClassForItem:",
+protocol: 'accessing',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4;
+$1=_st(anItem).__eq(self._allProtocol());
+$ctx1.sendIdx["="]=1;
+if(smalltalk.assert($1)){
+return "";
+};
+$2=_st(anItem).__eq("private");
+$ctx1.sendIdx["="]=2;
+if(smalltalk.assert($2)){
+return "private";
+};
+$3=_st(anItem).__eq("initialization");
+if(smalltalk.assert($3)){
+return "initialization";
+};
+$4=_st(anItem)._match_("^\x5c*");
+if(smalltalk.assert($4)){
+return "extension";
+};
+return "";
+}, function($ctx1) {$ctx1.fill(self,"cssClassForItem:",{anItem:anItem},globals.HLProtocolsListWidget)})},
+args: ["anItem"],
+source: "cssClassForItem: anItem\x0a\x09anItem = self allProtocol ifTrue: [ ^ '' ].\x0a\x09anItem = 'private' ifTrue: [ ^ 'private' ].\x0a\x09anItem = 'initialization' ifTrue: [ ^ 'initialization' ].\x0a\x09(anItem match: '^\x5c*') ifTrue: [ ^ 'extension' ].\x0a\x09^ ''",
+messageSends: ["ifTrue:", "=", "allProtocol", "match:"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Protocols";
+},
+args: [],
+source: "label\x0a\x09^ 'Protocols'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+function $HLShowInstanceToggled(){return globals.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
+function $HLProtocolSelected(){return globals.HLProtocolSelected||(typeof HLProtocolSelected=="undefined"?nil:HLProtocolSelected)}
+function $HLProtocolsFocusRequested(){return globals.HLProtocolsFocusRequested||(typeof HLProtocolsFocusRequested=="undefined"?nil:HLProtocolsFocusRequested)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLClassSelected(),"onClassSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($HLShowInstanceToggled(),"onClassSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st($1)._on_send_to_($HLProtocolSelected(),"onProtocolSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+$2=_st($1)._on_send_to_($HLProtocolsFocusRequested(),"onProtocolsFocusRequested",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLProtocolsListWidget)})},
+args: [],
+source: "observeModel\x0a    self model announcer \x0a\x09\x09on: HLClassSelected\x0a\x09\x09send: #onClassSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a    \x09on: HLShowInstanceToggled \x0a\x09\x09send: #onClassSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a    \x09on: HLProtocolSelected\x0a\x09\x09send: #onProtocolSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLProtocolsFocusRequested \x0a\x09\x09send: #onProtocolsFocusRequested\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLClassSelected", "HLShowInstanceToggled", "HLProtocolSelected", "HLProtocolsFocusRequested"]
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $ProtocolAdded(){return globals.ProtocolAdded||(typeof ProtocolAdded=="undefined"?nil:ProtocolAdded)}
+function $ProtocolRemoved(){return globals.ProtocolRemoved||(typeof ProtocolRemoved=="undefined"?nil:ProtocolRemoved)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._systemAnnouncer();
+_st($1)._on_send_to_($ProtocolAdded(),"onProtocolAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+$2=_st($1)._on_send_to_($ProtocolRemoved(),"onProtocolRemoved:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLProtocolsListWidget)})},
+args: [],
+source: "observeSystem\x0a\x09self model systemAnnouncer\x0a\x09\x09on: ProtocolAdded \x0a\x09\x09send: #onProtocolAdded:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: ProtocolRemoved\x0a\x09\x09send: #onProtocolRemoved:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "systemAnnouncer", "model"],
+referencedClasses: ["ProtocolAdded", "ProtocolRemoved"]
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectedItem_(nil);
+self._setItemsForSelectedClass();
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement},globals.HLProtocolsListWidget)})},
+args: ["anAnnouncement"],
+source: "onClassSelected: anAnnouncement\x0a    self selectedItem: nil.\x0a    \x0a    self setItemsForSelectedClass.\x0a    self refresh",
+messageSends: ["selectedItem:", "setItemsForSelectedClass", "refresh"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+class_=_st(anAnnouncement)._theClass();
+$1=_st(class_).__eq(_st(self._model())._selectedClass());
+if(! smalltalk.assert($1)){
+return self;
+};
+self._setItemsForSelectedClass();
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolAdded:",{anAnnouncement:anAnnouncement,class_:class_},globals.HLProtocolsListWidget)})},
+args: ["anAnnouncement"],
+source: "onProtocolAdded: anAnnouncement\x0a\x09| class |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09\x0a\x09class = self model selectedClass ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedClass.\x0a    self refresh",
+messageSends: ["theClass", "ifFalse:", "=", "selectedClass", "model", "setItemsForSelectedClass", "refresh"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolRemoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_,protocol;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$4,$3,$1,$5,$6;
+class_=_st(anAnnouncement)._theClass();
+protocol=_st(anAnnouncement)._protocol();
+$2=class_;
+$4=self._model();
+$ctx1.sendIdx["model"]=1;
+$3=_st($4)._selectedClass();
+$1=_st($2).__eq($3);
+$ctx1.sendIdx["="]=1;
+if(! smalltalk.assert($1)){
+return self;
+};
+$5=_st(_st(self._model())._selectedProtocol()).__eq(protocol);
+if(smalltalk.assert($5)){
+self._selectedItem_(nil);
+$6=self._selectItem_(nil);
+$6;
+};
+self._setItemsForSelectedClass();
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolRemoved:",{anAnnouncement:anAnnouncement,class_:class_,protocol:protocol},globals.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:", "selectedProtocol", "selectedItem:", "selectItem:", "setItemsForSelectedClass", "refresh"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var protocol;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$receiver;
+protocol=_st(anAnnouncement)._item();
+self._selectedItem_(protocol);
+$1=protocol;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+$2=self._hasFocus();
+if(! smalltalk.assert($2)){
+self._activateItem_(protocol);
+$3=self._focus();
+$3;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolSelected:",{anAnnouncement:anAnnouncement,protocol:protocol},globals.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:", "hasFocus", "activateItem:", "focus"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolsFocusRequested",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolsFocusRequested",{},globals.HLProtocolsListWidget)})},
+args: [],
+source: "onProtocolsFocusRequested\x0a\x09self focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+$1=_st(self._model())._showInstance();
+if(smalltalk.assert($1)){
+($ctx1.supercall = true, globals.HLProtocolsListWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+} else {
+$2=_st(html)._div();
+_st($2)._class_("class_side");
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLProtocolsListWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx2.supercall = false;
+$ctx2.sendIdx["renderContentOn:"]=1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$3;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.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:", "showInstance", "model", "class:", "div", "with:", "renderContentOn:"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reselectItem:",
+protocol: 'actions',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._forceSelectedProtocol_(anItem);
+return self}, function($ctx1) {$ctx1.fill(self,"reselectItem:",{anItem:anItem},globals.HLProtocolsListWidget)})},
+args: ["anItem"],
+source: "reselectItem: anItem\x0a\x09self model forceSelectedProtocol: anItem",
+messageSends: ["forceSelectedProtocol:", "model"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._selectedProtocol_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aString:aString},globals.HLProtocolsListWidget)})},
+args: ["aString"],
+source: "selectItem: aString\x0a    self model selectedProtocol: aString",
+messageSends: ["selectedProtocol:", "model"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedItem",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=($ctx1.supercall = true, globals.HLProtocolsListWidget.superclass.fn.prototype._selectedItem.apply(_st(self), []));
+$ctx1.supercall = false;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedItem",{},globals.HLProtocolsListWidget)})},
+args: [],
+source: "selectedItem\x0a\x09^ super selectedItem\x22 ifNil: [ self allProtocol ]\x22",
+messageSends: ["selectedItem"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setItemsForClass:",
+protocol: 'private',
+fn: function (aClass){
+var self=this;
+function $Array(){return globals.Array||(typeof Array=="undefined"?nil:Array)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+if(($receiver = aClass) == null || $receiver.isNil){
+$2=self._allProtocol();
+$ctx1.sendIdx["allProtocol"]=1;
+$1=_st($Array())._with_($2);
+$ctx1.sendIdx["with:"]=1;
+} else {
+$3=_st($Array())._with_(self._allProtocol());
+_st($3)._addAll_(_st(aClass)._protocols());
+$4=_st($3)._yourself();
+$1=$4;
+};
+self._items_($1);
+return self}, function($ctx1) {$ctx1.fill(self,"setItemsForClass:",{aClass:aClass},globals.HLProtocolsListWidget)})},
+args: ["aClass"],
+source: "setItemsForClass: aClass\x0a\x09self items: (aClass\x0a    \x09ifNil: [ Array with: self allProtocol ]\x0a      \x09ifNotNil: [ \x0a        \x09(Array with: self allProtocol) \x0a            \x09addAll: aClass protocols; \x0a                yourself ])",
+messageSends: ["items:", "ifNil:ifNotNil:", "with:", "allProtocol", "addAll:", "protocols", "yourself"],
+referencedClasses: ["Array"]
+}),
+globals.HLProtocolsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setItemsForSelectedClass",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._setItemsForClass_(_st(self._model())._selectedClass());
+return self}, function($ctx1) {$ctx1.fill(self,"setItemsForSelectedClass",{},globals.HLProtocolsListWidget)})},
+args: [],
+source: "setItemsForSelectedClass\x0a\x09self setItemsForClass: self model selectedClass",
+messageSends: ["setItemsForClass:", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLProtocolsListWidget);
+
+
+
+smalltalk.addClass('HLSelectorsCache', globals.Object, ['classesCache'], 'Helios-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cacheFor:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+if(($receiver = aClass) == null || $receiver.isNil){
+return nil;
+} else {
+aClass;
+};
+$1=_st(self._classesCache())._at_ifAbsentPut_(_st(aClass)._name(),(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._newCacheFor_(aClass);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cacheFor:",{aClass:aClass},globals.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:", "classesCache", "name", "newCacheFor:"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classesCache",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@classesCache"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@classesCache"]=_st($HashedCollection())._new();
+$1=self["@classesCache"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"classesCache",{},globals.HLSelectorsCache)})},
+args: [],
+source: "classesCache\x0a\x09^ classesCache ifNil: [ classesCache := HashedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HashedCollection"]
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLSelectorsCache.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._observeSystem();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLSelectorsCache)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a    self observeSystem",
+messageSends: ["initialize", "observeSystem"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "invalidateCacheFor:",
+protocol: 'private',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._cacheFor_(_st(aMethod)._methodClass()))._invalidateSelector_(_st(aMethod)._selector());
+return self}, function($ctx1) {$ctx1.fill(self,"invalidateCacheFor:",{aMethod:aMethod},globals.HLSelectorsCache)})},
+args: ["aMethod"],
+source: "invalidateCacheFor: aMethod\x0a\x09(self cacheFor: aMethod methodClass)\x0a    \x09invalidateSelector: aMethod selector",
+messageSends: ["invalidateSelector:", "cacheFor:", "methodClass", "selector"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isOverridden:",
+protocol: 'testing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._cacheFor_(_st(aMethod)._methodClass()))._isOverridden_(aMethod);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isOverridden:",{aMethod:aMethod},globals.HLSelectorsCache)})},
+args: ["aMethod"],
+source: "isOverridden: aMethod\x0a\x09^ (self cacheFor: aMethod methodClass)\x0a    \x09isOverridden: aMethod",
+messageSends: ["isOverridden:", "cacheFor:", "methodClass"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isOverride:",
+protocol: 'testing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._cacheFor_(_st(aMethod)._methodClass()))._isOverride_(aMethod);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isOverride:",{aMethod:aMethod},globals.HLSelectorsCache)})},
+args: ["aMethod"],
+source: "isOverride: aMethod\x0a\x09^ (self cacheFor: aMethod methodClass)\x0a    \x09isOverride: aMethod",
+messageSends: ["isOverride:", "cacheFor:", "methodClass"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "newCacheFor:",
+protocol: 'factory',
+fn: function (aClass){
+var self=this;
+function $HLClassCache(){return globals.HLClassCache||(typeof HLClassCache=="undefined"?nil:HLClassCache)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLClassCache())._on_selectorsCache_(aClass,self);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"newCacheFor:",{aClass:aClass},globals.HLSelectorsCache)})},
+args: ["aClass"],
+source: "newCacheFor: aClass\x0a\x09^ HLClassCache \x0a    \x09on: aClass\x0a        selectorsCache: self",
+messageSends: ["on:selectorsCache:"],
+referencedClasses: ["HLClassCache"]
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $SystemAnnouncer(){return globals.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
+function $MethodAdded(){return globals.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)}
+function $MethodRemoved(){return globals.MethodRemoved||(typeof MethodRemoved=="undefined"?nil:MethodRemoved)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($SystemAnnouncer())._current();
+_st($1)._on_send_to_($MethodAdded(),"onMethodAdded:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+$2=_st($1)._on_send_to_($MethodRemoved(),"onMethodRemoved:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLSelectorsCache)})},
+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: ["SystemAnnouncer", "MethodAdded", "MethodRemoved"]
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodAdded:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._invalidateCacheFor_(_st(anAnnouncement)._method());
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodAdded:",{anAnnouncement:anAnnouncement},globals.HLSelectorsCache)})},
+args: ["anAnnouncement"],
+source: "onMethodAdded: anAnnouncement\x0a\x09self invalidateCacheFor: anAnnouncement method",
+messageSends: ["invalidateCacheFor:", "method"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodRemoved:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._invalidateCacheFor_(_st(anAnnouncement)._method());
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodRemoved:",{anAnnouncement:anAnnouncement},globals.HLSelectorsCache)})},
+args: ["anAnnouncement"],
+source: "onMethodRemoved: anAnnouncement\x0a\x09self invalidateCacheFor: anAnnouncement method",
+messageSends: ["invalidateCacheFor:", "method"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache);
+
+
+globals.HLSelectorsCache.klass.iVarNames = ['current'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "current",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@current"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@current"]=($ctx1.supercall = true, globals.HLSelectorsCache.klass.superclass.fn.prototype._new.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=self["@current"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"current",{},globals.HLSelectorsCache.klass)})},
+args: [],
+source: "current\x0a\x09^ current ifNil: [ current := super new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "flush",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+self["@current"]=nil;
+return self},
+args: [],
+source: "flush\x0a\x09current := nil",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSelectorsCache.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "new",
+protocol: 'instance creation',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._shouldNotImplement();
+return self}, function($ctx1) {$ctx1.fill(self,"new",{},globals.HLSelectorsCache.klass)})},
+args: [],
+source: "new\x0a\x09self shouldNotImplement",
+messageSends: ["shouldNotImplement"],
+referencedClasses: []
+}),
+globals.HLSelectorsCache.klass);
+
+});

src/Helios-Browser.st

@@ -0,0 +1,1557 @@
+Smalltalk createPackage: 'Helios-Browser'!
+HLWidget subclass: #HLBrowser
+	instanceVariableNames: 'model packagesListWidget classesListWidget protocolsListWidget methodsListWidget sourceWidget bottomDiv'
+	package: 'Helios-Browser'!
+!HLBrowser commentStamp!
+I render a system browser with 4 panes (Packages, Classes, Protocols, Methods) and a source area.!
+
+!HLBrowser methodsFor: 'accessing'!
+
+environment
+	^ self model environment
+!
+
+model
+	^ model ifNil: [ self model: HLBrowserModel new. model ]
+!
+
+model: aModel
+	model := aModel.
+	self observeModel
+! !
+
+!HLBrowser methodsFor: 'actions'!
+
+focus
+	^ self packagesListWidget focus
+!
+
+observeModel
+	self model announcer
+		on: HLPackageSelected
+		send: #onPackageSelected:
+		to: self.
+		
+	self model announcer
+		on: HLClassSelected
+		send: #onClassSelected:
+		to: self
+!
+
+openClassNamed: aString
+	self model openClassNamed: aString
+!
+
+openMethod: aCompiledMethod
+	self model
+		"Workaround for the package selection announcement when the package list is focused"	
+		focusOnSourceCode;
+		selectedPackage: aCompiledMethod methodClass package;
+		selectedClass: aCompiledMethod methodClass;
+		selectedProtocol: aCompiledMethod protocol;
+		selectedMethod: aCompiledMethod;
+		focusOnSourceCode
+!
+
+unregister
+	super unregister.
+
+	{ 
+		self packagesListWidget.
+		self classesListWidget.
+		self protocolsListWidget.
+		self methodsListWidget.
+		self sourceWidget
+	} 
+		do: [ :each | each unregister ]
+! !
+
+!HLBrowser methodsFor: 'keybindings'!
+
+registerBindingsOn: aBindingGroup
+	HLToolCommand 
+		registerConcreteClassesOn: aBindingGroup 
+		for: self model
+! !
+
+!HLBrowser methodsFor: 'reactions'!
+
+onClassSelected: anAnnouncement
+	anAnnouncement item 
+		ifNil: [ self setTabLabel: (self model selectedPackage 
+			ifNil: [ self defaultTabLabel ]
+			ifNotNil: [ :package | package name ]) ] 
+		ifNotNil: [ :item | self setTabLabel: item name ]
+!
+
+onPackageSelected: anAnnouncement
+	anAnnouncement item ifNotNil: [ :item |
+	self setTabLabel: item name ]
+! !
+
+!HLBrowser methodsFor: 'rendering'!
+
+renderContentOn: html
+	html with: (HLContainer with: (HLHorizontalSplitter 
+    	with: (HLVerticalSplitter
+        	with: (HLVerticalSplitter
+            	with: self packagesListWidget
+                with: self classesListWidget)
+            with: (HLVerticalSplitter
+            	with: self protocolsListWidget
+                with: self methodsListWidget)) 
+        with: self sourceWidget)).
+	
+	self packagesListWidget focus
+! !
+
+!HLBrowser methodsFor: 'testing'!
+
+canHaveFocus
+	^ true
+! !
+
+!HLBrowser methodsFor: 'widgets'!
+
+classesListWidget
+	^ classesListWidget ifNil: [
+      	classesListWidget := HLClassesListWidget on: self model.
+		classesListWidget next: self protocolsListWidget ]
+!
+
+methodsListWidget
+	^ methodsListWidget ifNil: [
+      	methodsListWidget := HLMethodsListWidget on: self model.
+		methodsListWidget next: self sourceWidget ]
+!
+
+packagesListWidget
+	^ packagesListWidget ifNil: [
+      	packagesListWidget := HLPackagesListWidget on: self model.
+		packagesListWidget next: self classesListWidget ]
+!
+
+protocolsListWidget
+	^ protocolsListWidget ifNil: [
+      	protocolsListWidget := HLProtocolsListWidget on: self model.
+		protocolsListWidget next: self methodsListWidget ]
+!
+
+sourceWidget
+	^ sourceWidget ifNil: [
+      	sourceWidget := HLBrowserBottomWidget new
+			model: self model;
+			yourself ]
+! !
+
+HLBrowser class instanceVariableNames: 'nextId'!
+
+!HLBrowser class methodsFor: 'accessing'!
+
+nextId
+	nextId ifNil: [ nextId := 0 ].
+    ^ 'browser_', (nextId + 1) asString
+!
+
+tabClass
+	^ 'browser'
+!
+
+tabLabel
+	^ 'Browser'
+!
+
+tabPriority
+	^ 0
+! !
+
+!HLBrowser class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ true
+! !
+
+HLWidget subclass: #HLBrowserBottomWidget
+	instanceVariableNames: 'model codeWidget documentationWidget'
+	package: 'Helios-Browser'!
+!HLBrowserBottomWidget commentStamp!
+I render the code area of a browser and optionally the documentation for the selected class.!
+
+!HLBrowserBottomWidget methodsFor: 'accessing'!
+
+codeWidget
+	^ codeWidget ifNil: [ codeWidget := HLBrowserCodeWidget new
+		browserModel: self model;
+		yourself ]
+!
+
+documentationWidget
+	^ documentationWidget ifNil: [ documentationWidget := HLDocumentationWidget new
+		model: self model;
+		yourself ]
+!
+
+model
+	^ model
+!
+
+model: aModel
+	model := aModel.
+	self observeModel
+!
+
+previous
+	"For navigation"
+!
+
+previous: aWidget
+	"For navigation"
+! !
+
+!HLBrowserBottomWidget methodsFor: 'actions'!
+
+focus
+	self codeWidget focus
+!
+
+observeModel
+	self model announcer 
+		on: HLShowInstanceToggled
+		send: #onShowInstanceToggled
+		to: self;
+		on: HLShowCommentToggled
+		send: #onShowCommentToggled
+		to: self
+! !
+
+!HLBrowserBottomWidget methodsFor: 'reactions'!
+
+onShowCommentToggled
+	self refresh
+!
+
+onShowInstanceToggled
+	self refresh
+! !
+
+!HLBrowserBottomWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	self model showComment 
+		ifTrue: [ self renderPanesOn: html ]
+		ifFalse: [ html with: self codeWidget ]
+!
+
+renderPanesOn: html
+	html with: (HLVerticalSplitter
+		with: self codeWidget
+		with: self documentationWidget)
+! !
+
+!HLBrowserBottomWidget methodsFor: 'testing'!
+
+canHaveFocus
+	^ true
+! !
+
+HLToolModel subclass: #HLBrowserModel
+	instanceVariableNames: 'showInstance showComment'
+	package: 'Helios-Browser'!
+
+!HLBrowserModel methodsFor: 'accessing'!
+
+showComment
+	^ showComment ifNil: [ true ]
+!
+
+showComment: aBoolean
+	self withChangesDo: [
+		showComment := aBoolean.
+		self announcer announce: HLShowCommentToggled new ]
+!
+
+showInstance
+	^ showInstance ifNil: [ true ]
+!
+
+showInstance: aBoolean
+
+	self withChangesDo: [
+		showInstance := aBoolean.
+
+    	self selectedClass ifNotNil: [
+    		self selectedClass: (aBoolean
+    			ifTrue: [ self selectedClass theNonMetaClass ]
+	    	  	ifFalse: [ self selectedClass theMetaClass ]) ].
+    
+		self announcer announce: HLShowInstanceToggled new ]
+! !
+
+!HLBrowserModel methodsFor: 'actions'!
+
+focusOnClasses
+	self announcer announce: HLClassesFocusRequested new
+!
+
+focusOnDocumentation
+	self announcer announce: HLDocumentationFocusRequested new
+!
+
+focusOnMethods
+	self announcer announce: HLMethodsFocusRequested new
+!
+
+focusOnPackages
+	self announcer announce: HLPackagesFocusRequested new
+!
+
+focusOnProtocols
+	self announcer announce: HLProtocolsFocusRequested new
+!
+
+focusOnSourceCode
+	self announcer announce: HLSourceCodeFocusRequested new
+!
+
+setClassComment: aString
+	self environment
+		setClassCommentOf: self selectedClass theNonMetaClass
+		to: aString
+!
+
+showClassTemplate
+	self selectedPackage ifNotNil: [ :package |
+		self announcer announce: (HLShowTemplate new
+			template: package classTemplate;
+			yourself) ]
+!
+
+showMethodTemplate
+	self selectedClass ifNotNil: [ :theClass |
+		self announcer announce: (HLShowTemplate new
+			template: theClass methodTemplate;
+			yourself) ]
+! !
+
+!HLBrowserModel methodsFor: 'commands actions'!
+
+editComment
+	self announcer announce: HLEditComment new
+! !
+
+!HLBrowserModel methodsFor: 'testing'!
+
+isBrowserModel
+	^ true
+! !
+
+!HLBrowserModel class methodsFor: 'instance creation'!
+
+on: anEnvironment
+
+	^ self new
+    	environment: anEnvironment;
+        yourself
+! !
+
+Object subclass: #HLClassCache
+	instanceVariableNames: 'class selectorsCache overrideCache overriddenCache'
+	package: 'Helios-Browser'!
+
+!HLClassCache methodsFor: 'accessing'!
+
+overriddenCache
+	^ overriddenCache ifNil: [ overriddenCache := HashedCollection new ]
+!
+
+overrideCache
+	^ overrideCache ifNil: [ overrideCache := HashedCollection new ]
+!
+
+selectorsCache
+	^ selectorsCache
+!
+
+selectorsCache: aCache
+	selectorsCache := aCache
+!
+
+theClass
+	^ class
+!
+
+theClass: aClass
+	class := aClass
+! !
+
+!HLClassCache methodsFor: 'actions'!
+
+invalidateChildrenSelector: aSelector
+	self theClass subclasses do: [ :each |
+    	(self selectorsCache cacheFor: each)
+        	removeSelector: aSelector;
+        	invalidateChildrenSelector: aSelector ]
+!
+
+invalidateParentSelector: aSelector
+	self theClass superclass ifNotNil: [
+    	(self selectorsCache cacheFor: self theClass superclass)
+        	removeSelector: aSelector;
+			invalidateParentSelector: aSelector ]
+!
+
+invalidateSelector: aSelector
+	self 
+    	invalidateParentSelector: aSelector;
+        invalidateChildrenSelector: aSelector;
+        removeSelector: aSelector
+! !
+
+!HLClassCache methodsFor: 'private'!
+
+removeSelector: aSelector
+	self overriddenCache 
+    	removeKey: aSelector
+        ifAbsent: [ ].
+    self overrideCache 
+    	removeKey: aSelector
+        ifAbsent: [ ]
+! !
+
+!HLClassCache methodsFor: 'testing'!
+
+isOverridden: aMethod
+	^ self overriddenCache 
+    	at: aMethod selector
+      	ifAbsentPut: [ aMethod isOverridden ]
+!
+
+isOverride: aMethod
+	^ self overrideCache
+    	at: aMethod selector
+      	ifAbsentPut: [ aMethod isOverride ]
+! !
+
+!HLClassCache class methodsFor: 'instance creation'!
+
+on: aClass selectorsCache: aSelectorsCache
+	^ self new
+    	theClass: aClass;
+        selectorsCache: aSelectorsCache;
+        yourself
+! !
+
+HLToolListWidget subclass: #HLClassesListWidget
+	instanceVariableNames: ''
+	package: 'Helios-Browser'!
+!HLClassesListWidget commentStamp!
+I render a list of classes in the selected package.!
+
+!HLClassesListWidget methodsFor: 'accessing'!
+
+cssClassForItem: aClass
+	^ aClass theNonMetaClass heliosClass
+!
+
+getChildrenOf: aClass
+	^ self items select: [ :each | each superclass = aClass ]
+!
+
+getRootClassesOf: aCollection
+	^ aCollection select: [ :each |
+    		(aCollection includes: each superclass) not ]
+!
+
+label
+	^ 'Classes'
+! !
+
+!HLClassesListWidget methodsFor: 'actions'!
+
+focus
+	super focus.
+	
+	self selectedItem 
+		ifNil: [ self model showClassTemplate ]
+!
+
+focusMethodsListWidget
+	self model announcer announce: HLMethodsListFocus new
+!
+
+focusProtocolsListWidget
+	self model announcer announce: HLProtocolsListFocus new
+!
+
+observeModel
+	self model announcer 
+    	on: HLPackageSelected
+		send: #onPackageSelected:
+		to: self;
+		
+    	on: HLShowInstanceToggled 
+		send: #onShowInstanceToggled
+		to: self;
+		
+		on: HLShowCommentToggled
+		send: #onShowCommentToggled
+		to: self;
+		
+		on: HLClassSelected
+		send: #onClassSelected:
+		to: self;
+		
+		on: HLClassesFocusRequested
+		send: #onClassesFocusRequested
+		to: self
+!
+
+observeSystem
+	self model systemAnnouncer
+    	on: ClassAdded
+		send: #onClassAdded:
+		to: self;
+		
+        on: ClassRemoved
+        send: #onClassRemoved:
+		to: self;
+		
+		on: ClassMoved
+		send: #onClassMoved:
+		to: self;
+		
+		on: ClassRenamed
+		send: #onClassRenamed:
+		to: self;
+		
+		on: ClassMigrated
+		send: #onClassMigrated:
+		to: self;
+		
+		on: ClassCommentChanged
+        send: #onClassCommentChanged:
+		to: self
+!
+
+reselectItem: anItem
+	self model forceSelectedClass: anItem
+!
+
+selectItem: aClass
+    self model selectedClass: aClass
+!
+
+showComment: aBoolean
+	self model showComment: aBoolean
+!
+
+showInstance: aBoolean
+	self model showInstance: aBoolean
+!
+
+toggleShowComment
+	self model showComment: self showComment not
+! !
+
+!HLClassesListWidget methodsFor: 'private'!
+
+setItemsForPackage: aPackage
+	self items: (aPackage 
+    	ifNil: [ #() ]
+  		ifNotNil: [ (aPackage classes 
+        	collect: [ :each | each theNonMetaClass ]) 
+            	sort: [ :a :b | a name < b name ] ]).
+!
+
+setItemsForSelectedPackage
+	self setItemsForPackage: self model selectedPackage
+! !
+
+!HLClassesListWidget methodsFor: 'reactions'!
+
+onClassAdded: anAnnouncement
+	| class |
+	
+	class := anAnnouncement theClass.
+	
+	(class package = self model selectedPackage or: [
+		self items includes: class ]) ifFalse: [ ^ self ].
+    
+    self 
+		setItemsForSelectedPackage;
+		refresh;
+		focus
+!
+
+onClassCommentChanged: anAnnouncement
+	| class |
+	class := anAnnouncement theClass.
+
+	class package = self model selectedPackage ifFalse: [ ^ self ].
+    
+    self 
+		refresh;
+		focus
+!
+
+onClassMigrated: anAnnouncement
+	| class oldClass |
+	
+	class := anAnnouncement theClass.
+	oldClass := anAnnouncement oldClass.
+
+	(self items includes: oldClass) ifFalse: [ ^ self ].
+
+	self model selectedClass = oldClass ifTrue: [
+		self model selectedClass: class ].
+    
+    self setItemsForSelectedPackage.
+    self 
+		refresh;
+		focus
+!
+
+onClassMoved: anAnnouncement
+	| class oldPackage |
+	
+	class := anAnnouncement theClass.
+	oldPackage := anAnnouncement oldPackage.
+	
+	(oldPackage = self model selectedPackage or: [
+		class package = self model selectedPackage ])
+			ifFalse: [ ^ self ].
+	
+	oldPackage = self model selectedPackage ifTrue: [ 
+		self 
+			selectedItem: nil;
+			selectItem: nil ].
+    
+    self setItemsForSelectedPackage.
+    self 	
+		refresh;
+		focus
+!
+
+onClassRemoved: anAnnouncement
+	| class |
+	class := anAnnouncement theClass.
+
+	class package = self model selectedPackage ifFalse: [ ^ self ].
+    
+	self 
+		selectItem: nil;
+		selectedItem: nil.
+    self setItemsForSelectedPackage.
+    self 
+		refresh;
+		focus
+!
+
+onClassRenamed: anAnnouncement
+	anAnnouncement theClass package = self model selectedPackage ifFalse: [ ^ self ].
+    
+    self setItemsForSelectedPackage.
+    self 
+		refresh;
+		focus
+!
+
+onClassSelected: anAnnouncement
+	| selectedClass |
+	
+	anAnnouncement item ifNil: [ ^ self ].
+	
+	selectedClass := anAnnouncement item theNonMetaClass.
+	self selectedItem: selectedClass.
+
+	self hasFocus ifFalse: [
+		self 
+			activateItem: selectedClass;
+			focus ]
+!
+
+onClassesFocusRequested
+	self focus
+!
+
+onPackageSelected: anAnnouncement
+    self selectedItem: nil.
+    
+    self setItemsForSelectedPackage.
+    self refresh
+!
+
+onShowCommentToggled
+	self refresh
+!
+
+onShowInstanceToggled
+	self refresh
+! !
+
+!HLClassesListWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	| checkbox |
+	
+	html div 
+        class: 'btn-group';
+		with: [ 
+           	html button 
+                class: (String streamContents: [ :str |
+                	str nextPutAll: 'btn'.
+                    self showInstance ifTrue: [ 
+                    	str nextPutAll: ' active' ] ]);
+  				with: 'Instance';
+                onClick: [ self showInstance: true ].
+  			html button
+  				class: (String streamContents: [ :str |
+                	str nextPutAll: 'btn'.
+                    self showClass ifTrue: [ 
+                    	str nextPutAll: ' active' ] ]);
+  				with: 'Class';
+				onClick: [ self showInstance: false ] ].
+		html label 
+			class: 'checkbox';
+			with: [
+				checkbox := html input
+					type: 'checkbox';
+					onClick: [ self toggleShowComment ].
+				html with: 'Doc' ].
+				
+		self showComment ifTrue: [
+			checkbox at: 'checked' put: 'checked' ]
+!
+
+renderItem: aClass level: anInteger on: html
+	| li |
+    
+	li := html li.
+	li asJQuery data: 'item' put: aClass.
+    li
+		class: (self listCssClassForItem: aClass);
+		with: [ 
+        	html a
+            	with: [ 
+            		(html tag: 'i') class: (self cssClassForItem: aClass).
+  					self renderItemLabel: aClass level: anInteger on: html ];
+				onClick: [
+                  	self reactivateListItem: li asJQuery ] ].
+                    
+    (self getChildrenOf: aClass) do: [ :each |
+    	self renderItem: each level: anInteger + 1 on: html ]
+!
+
+renderItem: aClass on: html
+	super renderItem: aClass on: html.
+    (self getChildrenOf: aClass) do: [ :each |
+    	self renderItem: each level: 1 on: html ]
+!
+
+renderItemLabel: aClass level: anInteger on: html
+	html span asJQuery html: (String streamContents: [ :str |
+		anInteger timesRepeat: [
+			str nextPutAll: '&nbsp;&nbsp;&nbsp;&nbsp;' ].
+			str nextPutAll: aClass name ])
+!
+
+renderItemLabel: aClass on: html
+	self renderItemLabel: aClass level: 0 on: html
+!
+
+renderListOn: html
+	(self getRootClassesOf: self items)
+    	do: [ :each | self renderItem: each on: html ]
+! !
+
+!HLClassesListWidget methodsFor: 'testing'!
+
+showClass
+	^ self model showInstance not
+!
+
+showComment
+	^ self model showComment
+!
+
+showInstance
+	^ self model showInstance
+! !
+
+HLFocusableWidget subclass: #HLDocumentationWidget
+	instanceVariableNames: 'model'
+	package: 'Helios-Browser'!
+!HLDocumentationWidget commentStamp!
+I render the documentation for the selected class!
+
+!HLDocumentationWidget methodsFor: 'accessing'!
+
+documentation
+	^ self selectedItem 
+		ifNil: [ '' ]
+		ifNotNil: [ :item | item comment ifEmpty: [ self defaultDocumentation ] ]
+!
+
+head
+	^ self selectedItem 
+		ifNil: [ self defaultHead ]
+		ifNotNil: [ :item | item name ]
+!
+
+model
+	^ model
+!
+
+model: aModel
+	model := aModel.
+	self 
+		observeSystem;
+		observeModel
+!
+
+selectedItem
+	^ self model selectedClass ifNotNil: [ :class | class theNonMetaClass ]
+! !
+
+!HLDocumentationWidget methodsFor: 'actions'!
+
+editDocumentation
+	self model editComment
+!
+
+observeModel
+	self model announcer 
+		on: HLClassSelected
+		send: #onClassSelected:
+		to: self;
+		
+		on: HLEditComment
+		send: #onEditDocumentation
+		to: self;
+		
+		on: HLDocumentationFocusRequested
+		send: #onDocumentationFocusRequested
+		to: self
+!
+
+observeSystem
+	self model systemAnnouncer 
+		on: ClassCommentChanged
+		send: #onClassCommentChanged:
+		to: self
+!
+
+selectClass: aClass
+	self model selectedClass: aClass
+!
+
+unregister
+	super unregister.
+	self model announcer unregister: self
+! !
+
+!HLDocumentationWidget methodsFor: 'defaults'!
+
+defaultDocumentation
+	^ 'No documentation is available for this class.'
+!
+
+defaultHead
+	^ 'No class selected'
+! !
+
+!HLDocumentationWidget methodsFor: 'reactions'!
+
+onClassCommentChanged: anAnnouncement
+	self model selectedClass ifNil: [ ^ self ].
+	
+	anAnnouncement theClass = self model selectedClass theNonMetaClass
+		ifTrue: [ self refresh ]
+!
+
+onClassSelected: anAnnouncement
+	self refresh
+!
+
+onDocumentationFocusRequested
+	self focus
+!
+
+onEditDocumentation
+	self 
+		request: self model selectedClass theNonMetaClass name, ' comment'
+		value: self model selectedClass theNonMetaClass comment
+		do: [ :comment | self setClassComment: comment ]
+!
+
+setClassComment: aString
+	self model setClassComment: aString
+! !
+
+!HLDocumentationWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	html div 
+		class: 'doc';
+		with: [
+			self 
+				renderHeadOn: html;
+				renderDocOn: html ]
+!
+
+renderDocOn: html
+	self selectedItem ifNotNil: [
+		self renderInheritanceOn: html.
+		html h1 
+			with: 'Overview';
+			with: [ 
+				html button
+					class: 'button default';
+					with: 'Edit';
+					onClick: [ self editDocumentation ] ].
+		(html div 
+			class: 'markdown';
+			asJQuery) html: ((Showdown at: 'converter') new makeHtml: self documentation) ]
+!
+
+renderHeadOn: html
+	html div 
+		class: 'head';
+		with: self head
+!
+
+renderInheritanceOn: html
+	html div 	
+		class: 'inheritance';
+		with: [
+			html with: 'Subclass of '.
+			self selectedItem superclass 
+				ifNil: [ html em with: 'nil' ]
+				ifNotNil: [
+					html a 
+						with: self selectedItem superclass name;
+						onClick: [ self selectClass: self selectedItem superclass ] ] ]
+! !
+
+HLToolListWidget subclass: #HLMethodsListWidget
+	instanceVariableNames: 'selectorsCache'
+	package: 'Helios-Browser'!
+!HLMethodsListWidget commentStamp!
+I render a list of methods for the selected protocol.!
+
+!HLMethodsListWidget methodsFor: 'accessing'!
+
+allProtocol
+	^ self model allProtocol
+!
+
+cssClassForItem: aSelector
+	| override overriden method |
+    
+    method := self methodForSelector: aSelector.
+    override := self isOverride: method.
+    overriden := self isOverridden: method.
+    
+	^ override
+    	ifTrue: [ overriden
+			ifTrue: [ 'override-overridden' ]
+			ifFalse: [ 'override' ] ]
+		ifFalse: [
+			overriden
+			ifTrue: [ 'overridden' ]
+			ifFalse: [ '' ] ]
+!
+
+label
+	^ 'Methods'
+!
+
+methodForSelector: aSelector
+	^ self model selectedClass
+    	methodDictionary at: aSelector
+!
+
+methodsInProtocol: aString
+	self model selectedClass ifNil: [ ^ #() ].
+    
+	^ aString = self allProtocol
+    	ifTrue: [ self model selectedClass methods ]
+      	ifFalse: [ self model selectedClass methodsInProtocol: aString ]
+!
+
+overrideSelectors
+	^ self selectorsCache 
+    	at: 'override'
+        ifAbsentPut: [ 
+        	self model selectedClass allSuperclasses
+				inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]
+!
+
+overridenSelectors
+	^ self selectorsCache 
+    	at: 'overriden'
+        ifAbsentPut: [ 
+        	self model selectedClass allSubclasses
+				inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]
+!
+
+selectorsCache
+	^ self class selectorsCache
+!
+
+selectorsInProtocol: aString
+	^ ((self methodsInProtocol: aString)
+    	collect: [ :each | each selector ]) sorted
+! !
+
+!HLMethodsListWidget methodsFor: 'actions'!
+
+focus
+	super focus.
+	
+	self selectedItem ifNil: [
+		self model showMethodTemplate ]
+!
+
+observeModel
+	self model announcer 
+		on: HLProtocolSelected 
+		send: #onProtocolSelected: 
+		to: self;
+		
+		on: HLShowInstanceToggled 
+		send: #onShowInstanceToggled
+		to: self;
+		
+		on: HLMethodSelected 
+		send: #onMethodSelected:
+		to: self;
+		
+		on: HLMethodsFocusRequested 
+		send: #onMethodsFocusRequested
+		to: self
+!
+
+observeSystem
+	self model systemAnnouncer 
+    	on: ProtocolAdded
+        send: #onProtocolAdded:
+		to: self;
+    	
+		on: ProtocolRemoved
+        send: #onProtocolRemoved:
+		to: self;
+		
+    	on: MethodAdded 
+        send: #onMethodAdded:
+		to: self;
+		
+        on: MethodRemoved 
+        send: #onMethodRemoved:
+		to: self;
+		
+		on: MethodMoved 
+        send: #onMethodMoved:
+		to: self
+!
+
+reselectItem: aSelector
+	self model forceSelectedMethod: (self methodForSelector: aSelector)
+!
+
+selectItem: aSelector
+	aSelector ifNil: [ ^ self model selectedMethod: nil ].
+
+   	self model selectedMethod: (self methodForSelector: aSelector)
+! !
+
+!HLMethodsListWidget methodsFor: 'private'!
+
+setItemsForProtocol: aString
+	^ self items: (aString
+    	ifNil: [ #() ]
+      	ifNotNil: [ self selectorsInProtocol: aString ])
+!
+
+setItemsForSelectedProtocol
+	self setItemsForProtocol: self model selectedProtocol
+! !
+
+!HLMethodsListWidget methodsFor: 'reactions'!
+
+onMethodAdded: anAnnouncement
+	self model selectedClass = anAnnouncement method methodClass ifFalse: [ ^ self ].
+    
+    self setItemsForSelectedProtocol.
+    self refresh
+!
+
+onMethodMoved: anAnnouncement
+	self model selectedMethod = anAnnouncement method ifFalse: [ ^ self ].
+    
+	self model selectedProtocol = self model allProtocol ifFalse: [
+		self 
+			selectedItem: nil; 
+			selectItem: nil;
+			setItemsForSelectedProtocol;
+    		refresh ]
+!
+
+onMethodRemoved: anAnnouncement
+	| method |
+	
+	method := anAnnouncement method.
+	
+	self items detect: [ :each | each = method selector ] ifNone: [ ^ self ].
+
+    self selectedItem ifNotNil: [
+      	(method methodClass = self model selectedClass and: [ method selector = self selectedItem ])
+  			ifTrue: [ 
+				self selectedItem: nil; 
+				selectItem: nil ] ].
+
+    self setItemsForSelectedProtocol.
+	self 
+		refresh;
+		focus
+!
+
+onMethodSelected: anAnnouncement
+	| selector method |
+	
+	method := anAnnouncement item.
+	
+	selector := method isCompiledMethod 
+		ifTrue: [ method selector ]
+		ifFalse: [ nil ].
+		
+	self 
+		selectedItem: selector;
+		activateItem: selector
+!
+
+onMethodsFocusRequested
+	self focus
+!
+
+onProtocolAdded: anAnnouncement
+	self model selectedClass = anAnnouncement theClass ifFalse: [ ^ self ].
+	
+	self setItemsForSelectedProtocol.
+    self refresh.
+	self focus
+!
+
+onProtocolRemoved: anAnnouncement
+	self model selectedClass = anAnnouncement theClass ifFalse: [ ^ self ].
+	
+	self setItemsForSelectedProtocol.
+    self refresh.
+	self focus
+!
+
+onProtocolSelected: anAnnouncement
+    self selectedItem: nil.
+    
+	self setItemsForSelectedProtocol.
+    self refresh
+!
+
+onShowInstanceToggled
+	self onProtocolSelected: nil
+! !
+
+!HLMethodsListWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	self model showInstance
+    	ifFalse: [ html div 
+        	class: 'class_side'; 
+            with: [ super renderContentOn: html ] ]
+      	ifTrue: [ super renderContentOn: html ]
+!
+
+renderItemLabel: aSelector on: html
+	html with: aSelector
+! !
+
+!HLMethodsListWidget methodsFor: 'testing'!
+
+isOverridden: aMethod
+   ^ self selectorsCache isOverridden: aMethod
+!
+
+isOverride: aMethod
+   ^ self selectorsCache isOverride: aMethod
+! !
+
+HLMethodsListWidget class instanceVariableNames: 'selectorsCache'!
+
+!HLMethodsListWidget class methodsFor: 'accessing'!
+
+selectorsCache
+	^ HLSelectorsCache current
+! !
+
+HLToolListWidget subclass: #HLPackagesListWidget
+	instanceVariableNames: ''
+	package: 'Helios-Browser'!
+!HLPackagesListWidget commentStamp!
+I render a list of the system packages.!
+
+!HLPackagesListWidget methodsFor: 'accessing'!
+
+cssClassForItem: anItem	
+	^ anItem isDirty 
+		ifTrue: [ 'package_dirty' ]
+		ifFalse: [ 'package' ]
+!
+
+items
+	^ items ifNil: [ self initializeItems ]
+!
+
+label
+	^ 'Packages'
+! !
+
+!HLPackagesListWidget methodsFor: 'actions'!
+
+focusClassesListWidget
+	self model announcer announce: HLClassesListFocus new
+!
+
+observeModel
+    self model announcer 
+		on: HLPackageSelected
+		send: #onPackageSelected:
+		to: self;
+		
+		on: HLPackagesFocusRequested 
+		send: #onPackagesFocusRequested
+		to: self
+!
+
+observeSystem
+    self model systemAnnouncer 
+		on: ClassAdded 
+		send: #onClassAdded:
+		to: self.
+		
+	self model systemAnnouncer
+		on: PackageAdded
+		send: #onPackageAdded:
+		to: self.
+		
+	self model systemAnnouncer
+		on: PackageClean
+		send: #onPackageStateChanged
+		to: self.
+		
+	self model systemAnnouncer
+		on: PackageDirty
+		send: #onPackageStateChanged
+		to: self.
+!
+
+reselectItem: anItem
+	self model forceSelectedPackage: anItem
+!
+
+selectItem: aPackage
+	super selectItem: aPackage.
+	self model selectedPackage: aPackage
+! !
+
+!HLPackagesListWidget methodsFor: 'initialization'!
+
+initializeItems
+	^ items := self model packages 
+		sort: [ :a :b | a name < b name ]
+! !
+
+!HLPackagesListWidget methodsFor: 'reactions'!
+
+onClassAdded: anAnnouncement
+	"Amber doesn't have yet a global organizer for packages"
+	
+	(self items includes: anAnnouncement theClass package) ifFalse: [ 
+		self 
+			initializeItems;
+			refresh ]
+!
+
+onPackageAdded: anAnnouncement
+	self 
+		initializeItems;
+		refresh
+!
+
+onPackageSelected: anAnnouncement
+	| package |
+	
+	package := anAnnouncement item.
+	
+	self selectedItem: package.
+	self hasFocus ifFalse: [
+		self
+			activateItem: package;
+			focus ]
+!
+
+onPackageStateChanged
+	self refresh
+!
+
+onPackagesFocusRequested
+	self focus
+! !
+
+!HLPackagesListWidget methodsFor: 'rendering'!
+
+renderItemLabel: aPackage on: html
+	html with: aPackage name
+! !
+
+HLToolListWidget subclass: #HLProtocolsListWidget
+	instanceVariableNames: ''
+	package: 'Helios-Browser'!
+!HLProtocolsListWidget commentStamp!
+I render a list of protocols for the selected class.!
+
+!HLProtocolsListWidget methodsFor: 'accessing'!
+
+allProtocol
+	^ self model allProtocol
+!
+
+cssClassForItem: anItem
+	anItem = self allProtocol ifTrue: [ ^ '' ].
+	anItem = 'private' ifTrue: [ ^ 'private' ].
+	anItem = 'initialization' ifTrue: [ ^ 'initialization' ].
+	(anItem match: '^\*') ifTrue: [ ^ 'extension' ].
+	^ ''
+!
+
+label
+	^ 'Protocols'
+!
+
+selectedItem
+	^ super selectedItem" ifNil: [ self allProtocol ]"
+! !
+
+!HLProtocolsListWidget methodsFor: 'actions'!
+
+observeModel
+    self model announcer 
+		on: HLClassSelected
+		send: #onClassSelected:
+		to: self;
+		
+    	on: HLShowInstanceToggled 
+		send: #onClassSelected:
+		to: self;
+		
+    	on: HLProtocolSelected
+		send: #onProtocolSelected:
+		to: self;
+		
+		on: HLProtocolsFocusRequested 
+		send: #onProtocolsFocusRequested
+		to: self
+!
+
+observeSystem
+	self model systemAnnouncer
+		on: ProtocolAdded 
+		send: #onProtocolAdded:
+		to: self;
+		
+		on: ProtocolRemoved
+		send: #onProtocolRemoved:
+		to: self
+!
+
+reselectItem: anItem
+	self model forceSelectedProtocol: anItem
+!
+
+selectItem: aString
+    self model selectedProtocol: aString
+! !
+
+!HLProtocolsListWidget methodsFor: 'private'!
+
+setItemsForClass: aClass
+	self items: (aClass
+    	ifNil: [ Array with: self allProtocol ]
+      	ifNotNil: [ 
+        	(Array with: self allProtocol) 
+            	addAll: aClass protocols; 
+                yourself ])
+!
+
+setItemsForSelectedClass
+	self setItemsForClass: self model selectedClass
+! !
+
+!HLProtocolsListWidget methodsFor: 'reactions'!
+
+onClassSelected: anAnnouncement
+    self selectedItem: nil.
+    
+    self setItemsForSelectedClass.
+    self refresh
+!
+
+onProtocolAdded: anAnnouncement
+	| class |
+	
+	class := anAnnouncement theClass.
+	
+	class = self model selectedClass ifFalse: [ ^ self ].
+    
+    self setItemsForSelectedClass.
+    self refresh
+!
+
+onProtocolRemoved: anAnnouncement
+	| class protocol |
+	
+	class := anAnnouncement theClass.
+	protocol := anAnnouncement protocol.
+	
+	class = self model selectedClass ifFalse: [ ^ self ].
+    
+    self model selectedProtocol = protocol 
+    	ifTrue: [ 
+			self 
+				selectedItem: nil;
+				selectItem: nil ].
+        
+    self setItemsForSelectedClass.
+    self refresh
+!
+
+onProtocolSelected: anAnnouncement
+	| protocol |
+	
+	protocol := anAnnouncement item.
+	
+	self selectedItem: protocol.
+	protocol ifNil: [ ^ self ].
+    
+	self hasFocus ifFalse: [
+		self 
+			activateItem: protocol;
+			focus ]
+!
+
+onProtocolsFocusRequested
+	self focus
+! !
+
+!HLProtocolsListWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	self model showInstance
+    	ifFalse: [ html div 
+        	class: 'class_side'; 
+            with: [ super renderContentOn: html ] ]
+      	ifTrue: [ super renderContentOn: html ]
+! !
+
+Object subclass: #HLSelectorsCache
+	instanceVariableNames: 'classesCache'
+	package: 'Helios-Browser'!
+
+!HLSelectorsCache methodsFor: 'accessing'!
+
+cacheFor: aClass
+	aClass ifNil: [ ^ nil ].
+    
+	^ self classesCache
+    	at: aClass name
+        ifAbsentPut: [ self newCacheFor: aClass ]
+!
+
+classesCache
+	^ classesCache ifNil: [ classesCache := HashedCollection new ]
+! !
+
+!HLSelectorsCache methodsFor: 'actions'!
+
+observeSystem
+	SystemAnnouncer current
+		on: MethodAdded
+		send: #onMethodAdded:
+		to: self;
+		
+		on: MethodRemoved
+        send: #onMethodRemoved:
+		to: self
+! !
+
+!HLSelectorsCache methodsFor: 'factory'!
+
+newCacheFor: aClass
+	^ HLClassCache 
+    	on: aClass
+        selectorsCache: self
+! !
+
+!HLSelectorsCache methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+    self observeSystem
+! !
+
+!HLSelectorsCache methodsFor: 'private'!
+
+invalidateCacheFor: aMethod
+	(self cacheFor: aMethod methodClass)
+    	invalidateSelector: aMethod selector
+! !
+
+!HLSelectorsCache methodsFor: 'reactions'!
+
+onMethodAdded: anAnnouncement
+	self invalidateCacheFor: anAnnouncement method
+!
+
+onMethodRemoved: anAnnouncement
+	self invalidateCacheFor: anAnnouncement method
+! !
+
+!HLSelectorsCache methodsFor: 'testing'!
+
+isOverridden: aMethod
+	^ (self cacheFor: aMethod methodClass)
+    	isOverridden: aMethod
+!
+
+isOverride: aMethod
+	^ (self cacheFor: aMethod methodClass)
+    	isOverride: aMethod
+! !
+
+HLSelectorsCache class instanceVariableNames: 'current'!
+
+!HLSelectorsCache class methodsFor: 'accessing'!
+
+current
+	^ current ifNil: [ current := super new ]
+!
+
+flush
+	current := nil
+! !
+
+!HLSelectorsCache class methodsFor: 'instance creation'!
+
+new
+	self shouldNotImplement
+! !
+

src/Helios-Commands-Browser.js

@@ -0,0 +1,799 @@
+define("helios/Helios-Commands-Browser", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Commands-Tools"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Commands-Browser');
+smalltalk.packages["Helios-Commands-Browser"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLBrowserCommand', globals.HLToolCommand, [], 'Helios-Commands-Browser');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aModel)._isBrowserModel();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowserCommand.klass)})},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
+messageSends: ["isBrowserModel"],
+referencedClasses: []
+}),
+globals.HLBrowserCommand.klass);
+
+
+smalltalk.addClass('HLBrowserGoToCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aModel)._isBrowserModel();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowserGoToCommand.klass)})},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
+messageSends: ["isBrowserModel"],
+referencedClasses: []
+}),
+globals.HLBrowserGoToCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "g";
+},
+args: [],
+source: "key\x0a\x09^ 'g'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserGoToCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Go to";
+},
+args: [],
+source: "label\x0a\x09^ 'Go to'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserGoToCommand.klass);
+
+
+smalltalk.addClass('HLGoToClassesCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._focusOnClasses();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToClassesCommand)})},
+args: [],
+source: "execute\x0a\x09self model focusOnClasses",
+messageSends: ["focusOnClasses", "model"],
+referencedClasses: []
+}),
+globals.HLGoToClassesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToClassesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "label\x0a\x09^ 'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToClassesCommand.klass);
+
+
+smalltalk.addClass('HLGoToDocumentationCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._focusOnDocumentation();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToDocumentationCommand)})},
+args: [],
+source: "execute\x0a\x09self model focusOnDocumentation",
+messageSends: ["focusOnDocumentation", "model"],
+referencedClasses: []
+}),
+globals.HLGoToDocumentationCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "d";
+},
+args: [],
+source: "key\x0a\x09^ 'd'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToDocumentationCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Documentation";
+},
+args: [],
+source: "label\x0a\x09^ 'Documentation'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToDocumentationCommand.klass);
+
+
+smalltalk.addClass('HLGoToMethodsCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._focusOnMethods();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToMethodsCommand)})},
+args: [],
+source: "execute\x0a\x09self model focusOnMethods",
+messageSends: ["focusOnMethods", "model"],
+referencedClasses: []
+}),
+globals.HLGoToMethodsCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "m";
+},
+args: [],
+source: "key\x0a\x09^ 'm'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToMethodsCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Methods";
+},
+args: [],
+source: "label\x0a\x09^ 'Methods'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToMethodsCommand.klass);
+
+
+smalltalk.addClass('HLGoToPackagesCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._focusOnPackages();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToPackagesCommand)})},
+args: [],
+source: "execute\x0a\x09self model focusOnPackages",
+messageSends: ["focusOnPackages", "model"],
+referencedClasses: []
+}),
+globals.HLGoToPackagesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "p";
+},
+args: [],
+source: "key\x0a\x09^ 'p'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToPackagesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Packages";
+},
+args: [],
+source: "label\x0a\x09^ 'Packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToPackagesCommand.klass);
+
+
+smalltalk.addClass('HLGoToProtocolsCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._focusOnProtocols();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToProtocolsCommand)})},
+args: [],
+source: "execute\x0a\x09self model focusOnProtocols",
+messageSends: ["focusOnProtocols", "model"],
+referencedClasses: []
+}),
+globals.HLGoToProtocolsCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "t";
+},
+args: [],
+source: "key\x0a\x09^ 't'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToProtocolsCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Protocols";
+},
+args: [],
+source: "label\x0a\x09^ 'Protocols'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToProtocolsCommand.klass);
+
+
+smalltalk.addClass('HLGoToSourceCodeCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._focusOnSourceCode();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToSourceCodeCommand)})},
+args: [],
+source: "execute\x0a\x09self model focusOnSourceCode",
+messageSends: ["focusOnSourceCode", "model"],
+referencedClasses: []
+}),
+globals.HLGoToSourceCodeCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "s";
+},
+args: [],
+source: "key\x0a\x09^ 's'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToSourceCodeCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Source code";
+},
+args: [],
+source: "label\x0a\x09^ 'Source code'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGoToSourceCodeCommand.klass);
+
+
+smalltalk.addClass('HLEditCommentCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._editComment();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLEditCommentCommand)})},
+args: [],
+source: "execute\x0a\x09self model editComment",
+messageSends: ["editComment", "model"],
+referencedClasses: []
+}),
+globals.HLEditCommentCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1;
+$3=self._model();
+$ctx1.sendIdx["model"]=1;
+$2=_st($3)._showComment();
+$1=_st($2)._and_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(self._model())._selectedClass())._notNil();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLEditCommentCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model showComment and: [ self model selectedClass notNil ]",
+messageSends: ["and:", "showComment", "model", "notNil", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLEditCommentCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "d";
+},
+args: [],
+source: "key\x0a\x09^ 'd'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLEditCommentCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Edit documentation";
+},
+args: [],
+source: "label\x0a\x09^ 'Edit documentation'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLEditCommentCommand.klass);
+
+
+smalltalk.addClass('HLGenerateCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+globals.HLGenerateCommand.comment="I am a group command used to gather all the commands generating code (`accessors`, `initialize`, etc)";
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "h";
+},
+args: [],
+source: "key\x0a\x09^ 'h'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerateCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Generate";
+},
+args: [],
+source: "label\x0a\x09^ 'Generate'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerateCommand.klass);
+
+
+smalltalk.addClass('HLCategorizeUnclassifiedCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+globals.HLCategorizeUnclassifiedCommand.comment="I am the command used to categorize unclassified methods";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+var targetClass,unclassified;
+function $HLMethodClassifier(){return globals.HLMethodClassifier||(typeof HLMethodClassifier=="undefined"?nil:HLMethodClassifier)}
+return smalltalk.withContext(function($ctx1) { 
+targetClass=_st(self._model())._selectedClass();
+unclassified=_st(_st(targetClass)._methods())._select_((function(e){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(e)._protocol()).__eq("as yet unclassified");
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)})}));
+_st(_st($HLMethodClassifier())._new())._classifyAll_(unclassified);
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,unclassified:unclassified},globals.HLCategorizeUnclassifiedCommand)})},
+args: [],
+source: "execute\x0a\x09| targetClass unclassified |\x0a\x09targetClass := self model selectedClass.\x0a\x0a\x09unclassified := targetClass methods select:[ :e | e protocol = 'as yet unclassified' ].\x0a\x09\x09\x0a\x09HLMethodClassifier new\x0a\x09\x09classifyAll: unclassified",
+messageSends: ["selectedClass", "model", "select:", "methods", "=", "protocol", "classifyAll:", "new"],
+referencedClasses: ["HLMethodClassifier"]
+}),
+globals.HLCategorizeUnclassifiedCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCategorizeUnclassifiedCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Categorize";
+},
+args: [],
+source: "label\x0a\x09^ 'Categorize'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCategorizeUnclassifiedCommand.klass);
+
+
+smalltalk.addClass('HLGenerateAccessorsCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+globals.HLGenerateAccessorsCommand.comment="I am the command used to generate the `getter` and the `setter` methods depending of the selected class";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+var targetClass,output,first;
+function $HLInitializeGenerator(){return globals.HLInitializeGenerator||(typeof HLInitializeGenerator=="undefined"?nil:HLInitializeGenerator)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5;
+$1=self._model();
+$ctx1.sendIdx["model"]=1;
+targetClass=_st($1)._selectedClass();
+$2=_st($HLInitializeGenerator())._new();
+_st($2)._class_(targetClass);
+_st($2)._generate();
+$3=_st($2)._output();
+output=$3;
+_st(output)._compile();
+first=_st(_st(output)._sourceCodes())._first();
+$4=self._model();
+_st($4)._selectedProtocol_(_st(output)._protocol());
+_st($4)._selectedMethod_(_st(targetClass).__gt_gt(_st(first)._selector()));
+$5=_st($4)._focusOnSourceCode();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output,first:first},globals.HLGenerateAccessorsCommand)})},
+args: [],
+source: "execute\x0a\x09| targetClass output first |\x0a\x09targetClass := self model selectedClass.\x0a\x0a\x09output := HLInitializeGenerator new\x0a\x09\x09class: targetClass;\x0a\x09\x09generate;\x0a\x09\x09output.\x0a\x09\x09\x0a\x09output compile.\x0a\x09first := output sourceCodes first.\x0a\x09self model\x0a\x09\x09selectedProtocol: output protocol;\x0a\x09\x09selectedMethod:(targetClass>>first selector);\x0a\x09\x09focusOnSourceCode",
+messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "first", "sourceCodes", "selectedProtocol:", "protocol", "selectedMethod:", ">>", "selector", "focusOnSourceCode"],
+referencedClasses: ["HLInitializeGenerator"]
+}),
+globals.HLGenerateAccessorsCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "i";
+},
+args: [],
+source: "key\x0a\x09^ 'i'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerateAccessorsCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Initialize";
+},
+args: [],
+source: "label\x0a\x09^ 'Initialize'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerateAccessorsCommand.klass);
+
+
+smalltalk.addClass('HLGenerateInitializeCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+globals.HLGenerateInitializeCommand.comment="I am the command used to generate the `initialize` method depending of the selected class";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+var targetClass,output;
+function $HLAccessorsGenerator(){return globals.HLAccessorsGenerator||(typeof HLAccessorsGenerator=="undefined"?nil:HLAccessorsGenerator)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+$1=self._model();
+$ctx1.sendIdx["model"]=1;
+targetClass=_st($1)._selectedClass();
+$2=_st($HLAccessorsGenerator())._new();
+_st($2)._class_(targetClass);
+_st($2)._generate();
+$3=_st($2)._output();
+output=$3;
+_st(output)._compile();
+_st(self._model())._selectedProtocol_(_st(output)._protocol());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output},globals.HLGenerateInitializeCommand)})},
+args: [],
+source: "execute\x0a\x09| targetClass output |\x0a\x09targetClass := self model selectedClass.\x0a\x0a\x09output := HLAccessorsGenerator new\x0a\x09\x09class: targetClass;\x0a\x09\x09generate;\x0a\x09\x09output.\x0a\x09\x09\x0a\x09output compile.\x0a\x09self model selectedProtocol: output protocol",
+messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "selectedProtocol:", "protocol"],
+referencedClasses: ["HLAccessorsGenerator"]
+}),
+globals.HLGenerateInitializeCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "a";
+},
+args: [],
+source: "key\x0a\x09^ 'a'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerateInitializeCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Accessors";
+},
+args: [],
+source: "label\x0a\x09^ 'Accessors'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerateInitializeCommand.klass);
+
+
+smalltalk.addClass('HLToggleCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "t";
+},
+args: [],
+source: "key\x0a\x09^ 't'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToggleCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Toggle";
+},
+args: [],
+source: "label\x0a\x09^ 'Toggle'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToggleCommand.klass);
+
+
+smalltalk.addClass('HLToggleClassCommentCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._model();
+$ctx1.sendIdx["model"]=1;
+_st($1)._showComment_(_st(_st(self._model())._showComment())._not());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleClassCommentCommand)})},
+args: [],
+source: "execute\x0a\x09self model showComment: self model showComment not",
+messageSends: ["showComment:", "model", "not", "showComment"],
+referencedClasses: []
+}),
+globals.HLToggleClassCommentCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "d";
+},
+args: [],
+source: "key\x0a\x09^ 'd'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToggleClassCommentCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Documentation";
+},
+args: [],
+source: "label\x0a\x09^ 'Documentation'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToggleClassCommentCommand.klass);
+
+
+smalltalk.addClass('HLToggleClassSideCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._model();
+$ctx1.sendIdx["model"]=1;
+_st($1)._showInstance_(_st(_st(self._model())._showInstance())._not());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleClassSideCommand)})},
+args: [],
+source: "execute\x0a\x09self model showInstance: self model showInstance not",
+messageSends: ["showInstance:", "model", "not", "showInstance"],
+referencedClasses: []
+}),
+globals.HLToggleClassSideCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToggleClassSideCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Class side";
+},
+args: [],
+source: "label\x0a\x09^ 'Class side'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToggleClassSideCommand.klass);
+
+});

src/Helios-Commands-Browser.st

@@ -0,0 +1,341 @@
+Smalltalk createPackage: 'Helios-Commands-Browser'!
+HLToolCommand subclass: #HLBrowserCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLBrowserCommand class methodsFor: 'testing'!
+
+isValidFor: aModel
+	^ aModel isBrowserModel
+! !
+
+HLBrowserCommand subclass: #HLBrowserGoToCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLBrowserGoToCommand class methodsFor: 'accessing'!
+
+key
+	^ 'g'
+!
+
+label
+	^ 'Go to'
+! !
+
+!HLBrowserGoToCommand class methodsFor: 'testing'!
+
+isValidFor: aModel
+	^ aModel isBrowserModel
+! !
+
+HLBrowserGoToCommand subclass: #HLGoToClassesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLGoToClassesCommand methodsFor: 'executing'!
+
+execute
+	self model focusOnClasses
+! !
+
+!HLGoToClassesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Classes'
+! !
+
+HLBrowserGoToCommand subclass: #HLGoToDocumentationCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLGoToDocumentationCommand methodsFor: 'executing'!
+
+execute
+	self model focusOnDocumentation
+! !
+
+!HLGoToDocumentationCommand class methodsFor: 'accessing'!
+
+key
+	^ 'd'
+!
+
+label
+	^ 'Documentation'
+! !
+
+HLBrowserGoToCommand subclass: #HLGoToMethodsCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLGoToMethodsCommand methodsFor: 'executing'!
+
+execute
+	self model focusOnMethods
+! !
+
+!HLGoToMethodsCommand class methodsFor: 'accessing'!
+
+key
+	^ 'm'
+!
+
+label
+	^ 'Methods'
+! !
+
+HLBrowserGoToCommand subclass: #HLGoToPackagesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLGoToPackagesCommand methodsFor: 'executing'!
+
+execute
+	self model focusOnPackages
+! !
+
+!HLGoToPackagesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'p'
+!
+
+label
+	^ 'Packages'
+! !
+
+HLBrowserGoToCommand subclass: #HLGoToProtocolsCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLGoToProtocolsCommand methodsFor: 'executing'!
+
+execute
+	self model focusOnProtocols
+! !
+
+!HLGoToProtocolsCommand class methodsFor: 'accessing'!
+
+key
+	^ 't'
+!
+
+label
+	^ 'Protocols'
+! !
+
+HLBrowserGoToCommand subclass: #HLGoToSourceCodeCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLGoToSourceCodeCommand methodsFor: 'executing'!
+
+execute
+	self model focusOnSourceCode
+! !
+
+!HLGoToSourceCodeCommand class methodsFor: 'accessing'!
+
+key
+	^ 's'
+!
+
+label
+	^ 'Source code'
+! !
+
+HLBrowserCommand subclass: #HLEditCommentCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLEditCommentCommand methodsFor: 'executing'!
+
+execute
+	self model editComment
+! !
+
+!HLEditCommentCommand methodsFor: 'testing'!
+
+isActive
+	^ self model showComment and: [ self model selectedClass notNil ]
+! !
+
+!HLEditCommentCommand class methodsFor: 'accessing'!
+
+key
+	^ 'd'
+!
+
+label
+	^ 'Edit documentation'
+! !
+
+HLBrowserCommand subclass: #HLGenerateCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+!HLGenerateCommand commentStamp!
+I am a group command used to gather all the commands generating code (`accessors`, `initialize`, etc)!
+
+!HLGenerateCommand class methodsFor: 'accessing'!
+
+key
+	^ 'h'
+!
+
+label
+	^ 'Generate'
+! !
+
+HLGenerateCommand subclass: #HLCategorizeUnclassifiedCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+!HLCategorizeUnclassifiedCommand commentStamp!
+I am the command used to categorize unclassified methods!
+
+!HLCategorizeUnclassifiedCommand methodsFor: 'executing'!
+
+execute
+	| targetClass unclassified |
+	targetClass := self model selectedClass.
+
+	unclassified := targetClass methods select:[ :e | e protocol = 'as yet unclassified' ].
+		
+	HLMethodClassifier new
+		classifyAll: unclassified
+! !
+
+!HLCategorizeUnclassifiedCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Categorize'
+! !
+
+HLGenerateCommand subclass: #HLGenerateAccessorsCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+!HLGenerateAccessorsCommand commentStamp!
+I am the command used to generate the `getter` and the `setter` methods depending of the selected class!
+
+!HLGenerateAccessorsCommand methodsFor: 'executing'!
+
+execute
+	| targetClass output first |
+	targetClass := self model selectedClass.
+
+	output := HLInitializeGenerator new
+		class: targetClass;
+		generate;
+		output.
+		
+	output compile.
+	first := output sourceCodes first.
+	self model
+		selectedProtocol: output protocol;
+		selectedMethod:(targetClass>>first selector);
+		focusOnSourceCode
+! !
+
+!HLGenerateAccessorsCommand class methodsFor: 'accessing'!
+
+key
+	^ 'i'
+!
+
+label
+	^ 'Initialize'
+! !
+
+HLGenerateCommand subclass: #HLGenerateInitializeCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+!HLGenerateInitializeCommand commentStamp!
+I am the command used to generate the `initialize` method depending of the selected class!
+
+!HLGenerateInitializeCommand methodsFor: 'executing'!
+
+execute
+	| targetClass output |
+	targetClass := self model selectedClass.
+
+	output := HLAccessorsGenerator new
+		class: targetClass;
+		generate;
+		output.
+		
+	output compile.
+	self model selectedProtocol: output protocol
+! !
+
+!HLGenerateInitializeCommand class methodsFor: 'accessing'!
+
+key
+	^ 'a'
+!
+
+label
+	^ 'Accessors'
+! !
+
+HLBrowserCommand subclass: #HLToggleCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLToggleCommand class methodsFor: 'accessing'!
+
+key
+	^ 't'
+!
+
+label
+	^ 'Toggle'
+! !
+
+HLToggleCommand subclass: #HLToggleClassCommentCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLToggleClassCommentCommand methodsFor: 'executing'!
+
+execute
+	self model showComment: self model showComment not
+! !
+
+!HLToggleClassCommentCommand class methodsFor: 'accessing'!
+
+key
+	^ 'd'
+!
+
+label
+	^ 'Documentation'
+! !
+
+HLToggleCommand subclass: #HLToggleClassSideCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Browser'!
+
+!HLToggleClassSideCommand methodsFor: 'executing'!
+
+execute
+	self model showInstance: self model showInstance not
+! !
+
+!HLToggleClassSideCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Class side'
+! !
+

src/Helios-Commands-Core.js

@@ -0,0 +1,1002 @@
+define("helios/Helios-Commands-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Commands-Core');
+smalltalk.packages["Helios-Commands-Core"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLCommand', globals.Object, ['input'], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "asActionBinding",
+protocol: 'converting',
+fn: function (){
+var self=this;
+function $HLBindingAction(){return globals.HLBindingAction||(typeof HLBindingAction=="undefined"?nil:HLBindingAction)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=_st($HLBindingAction())._on_labelled_(self._keyCode(),self._label());
+_st($2)._command_(self);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"asActionBinding",{},globals.HLCommand)})},
+args: [],
+source: "asActionBinding\x0a\x09^ (HLBindingAction on: self keyCode labelled: self label)\x0a    \x09command: self;\x0a\x09\x09yourself",
+messageSends: ["command:", "on:labelled:", "keyCode", "label", "yourself"],
+referencedClasses: ["HLBindingAction"]
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "asBinding",
+protocol: 'converting',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=self._isBindingGroup();
+if(smalltalk.assert($2)){
+$1=self._asGroupBinding();
+} else {
+$1=self._asActionBinding();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"asBinding",{},globals.HLCommand)})},
+args: [],
+source: "asBinding\x0a\x09^ self isBindingGroup\x0a\x09\x09ifTrue: [ self asGroupBinding ]\x0a\x09\x09ifFalse: [ self asActionBinding ]",
+messageSends: ["ifTrue:ifFalse:", "isBindingGroup", "asGroupBinding", "asActionBinding"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "asGroupBinding",
+protocol: 'converting',
+fn: function (){
+var self=this;
+function $HLBindingGroup(){return globals.HLBindingGroup||(typeof HLBindingGroup=="undefined"?nil:HLBindingGroup)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLBindingGroup())._on_labelled_(self._keyCode(),self._label());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"asGroupBinding",{},globals.HLCommand)})},
+args: [],
+source: "asGroupBinding\x0a\x09^ HLBindingGroup \x0a\x09\x09on: self keyCode\x0a\x09\x09labelled: self label",
+messageSends: ["on:labelled:", "keyCode", "label"],
+referencedClasses: ["HLBindingGroup"]
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commandError:",
+protocol: 'error handling',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._error_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"commandError:",{aString:aString},globals.HLCommand)})},
+args: ["aString"],
+source: "commandError: aString\x0a\x09self error: aString",
+messageSends: ["error:"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultInput",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return "";
+},
+args: [],
+source: "defaultInput\x0a\x09^ ''",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "documentation",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._documentation();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"documentation",{},globals.HLCommand)})},
+args: [],
+source: "documentation\x0a\x09^ self class documentation",
+messageSends: ["documentation", "class"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "execute",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "input",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@input"];
+return $1;
+},
+args: [],
+source: "input\x0a\x09^ input",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "input:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+var $1;
+self["@input"]=aString;
+$1=self["@input"];
+return $1;
+},
+args: ["aString"],
+source: "input: aString\x0a\x09^ input := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=[];
+return $1;
+},
+args: [],
+source: "inputCompletion\x0a\x09^ #()",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputLabel",{},globals.HLCommand)})},
+args: [],
+source: "inputLabel\x0a\x09^ self label",
+messageSends: ["label"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isAction",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._isBindingGroup())._not();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isAction",{},globals.HLCommand)})},
+args: [],
+source: "isAction\x0a\x09^ self isBindingGroup not",
+messageSends: ["not", "isBindingGroup"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isActive\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isBindingGroup",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(self._class())._methodDictionary())._includesKey_("execute"))._not();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isBindingGroup",{},globals.HLCommand)})},
+args: [],
+source: "isBindingGroup\x0a\x09^ (self class methodDictionary includesKey: 'execute') not",
+messageSends: ["not", "includesKey:", "methodDictionary", "class"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._key();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"key",{},globals.HLCommand)})},
+args: [],
+source: "key\x0a\x09^ self class key",
+messageSends: ["key", "class"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "keyCode",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._key())._asUppercase())._charCodeAt_((1));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"keyCode",{},globals.HLCommand)})},
+args: [],
+source: "keyCode\x0a\x09^ self key asUppercase charCodeAt: 1",
+messageSends: ["charCodeAt:", "asUppercase", "key"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"label",{},globals.HLCommand)})},
+args: [],
+source: "label\x0a\x09^ self class label",
+messageSends: ["label", "class"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._menuLabel();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"menuLabel",{},globals.HLCommand)})},
+args: [],
+source: "menuLabel\x0a\x09^ self class menuLabel",
+messageSends: ["menuLabel", "class"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerOn:",
+protocol: 'registration',
+fn: function (aBinding){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aBinding)._add_(self._asBinding());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},globals.HLCommand)})},
+args: ["aBinding"],
+source: "registerOn: aBinding\x0a\x09^ aBinding add: self asBinding",
+messageSends: ["add:", "asBinding"],
+referencedClasses: []
+}),
+globals.HLCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "concreteClasses",
+protocol: 'registration',
+fn: function (){
+var self=this;
+var classes;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+classes=_st($OrderedCollection())._new();
+$1=self._isConcrete();
+if(smalltalk.assert($1)){
+_st(classes)._add_(self);
+};
+_st(self._subclasses())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(classes)._addAll_(_st(each)._concreteClasses());
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+$2=classes;
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"concreteClasses",{classes:classes},globals.HLCommand.klass)})},
+args: [],
+source: "concreteClasses\x0a\x09| classes |\x0a\x09\x0a\x09classes := OrderedCollection new.\x0a\x09\x0a\x09self isConcrete\x0a\x09\x09ifTrue: [ classes add: self ].\x0a\x09\x09\x0a\x09self subclasses do: [ :each | \x0a\x09\x09classes addAll: each concreteClasses ].\x0a\x09\x09\x0a\x09^ classes",
+messageSends: ["new", "ifTrue:", "isConcrete", "add:", "do:", "subclasses", "addAll:", "concreteClasses"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "documentation",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "";
+},
+args: [],
+source: "documentation\x0a\x09^ ''",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isConcrete",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._key())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isConcrete",{},globals.HLCommand.klass)})},
+args: [],
+source: "isConcrete\x0a\x09^ self key notNil",
+messageSends: ["notNil", "key"],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+return true;
+},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return nil;
+},
+args: [],
+source: "key\x0a\x09\x22Answer a single character string or nil if no key\x22\x0a\x09\x0a\x09^ nil",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "";
+},
+args: [],
+source: "label\x0a\x09^ ''",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"menuLabel",{},globals.HLCommand.klass)})},
+args: [],
+source: "menuLabel\x0a\x09^ self label",
+messageSends: ["label"],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerConcreteClassesOn:",
+protocol: 'accessing',
+fn: function (aBinding){
+var self=this;
+var newBinding;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._isConcrete();
+if(smalltalk.assert($1)){
+newBinding=self._registerOn_(aBinding);
+newBinding;
+} else {
+newBinding=aBinding;
+newBinding;
+};
+_st(self._subclasses())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._registerConcreteClassesOn_(newBinding);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:",{aBinding:aBinding,newBinding:newBinding},globals.HLCommand.klass)})},
+args: ["aBinding"],
+source: "registerConcreteClassesOn: aBinding\x0a\x09| newBinding |\x0a\x09\x0a\x09self isConcrete\x0a\x09\x09ifTrue: [ newBinding := self registerOn: aBinding ]\x0a\x09\x09ifFalse: [ newBinding := aBinding ].\x0a\x09\x09\x0a\x09self subclasses do: [ :each | each registerConcreteClassesOn: newBinding ]",
+messageSends: ["ifTrue:ifFalse:", "isConcrete", "registerOn:", "do:", "subclasses", "registerConcreteClassesOn:"],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerOn:",
+protocol: 'registration',
+fn: function (aBinding){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._new())._registerOn_(aBinding);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},globals.HLCommand.klass)})},
+args: ["aBinding"],
+source: "registerOn: aBinding\x0a\x09^ self new registerOn: aBinding",
+messageSends: ["registerOn:", "new"],
+referencedClasses: []
+}),
+globals.HLCommand.klass);
+
+
+smalltalk.addClass('HLCloseTabCommand', globals.HLCommand, [], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLManager())._current())._removeActiveTab();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCloseTabCommand)})},
+args: [],
+source: "execute\x0a\x09HLManager current removeActiveTab",
+messageSends: ["removeActiveTab", "current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLCloseTabCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "w";
+},
+args: [],
+source: "key\x0a\x09^ 'w'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCloseTabCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Close tab";
+},
+args: [],
+source: "label\x0a\x09^ 'Close tab'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCloseTabCommand.klass);
+
+
+smalltalk.addClass('HLModelCommand', globals.HLCommand, ['model'], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@model"];
+return $1;
+},
+args: [],
+source: "model\x0a\x09^ model",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModelCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+self["@model"]=aModel;
+return self},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModelCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "for:",
+protocol: 'instance creation',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._new();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"for:",{aModel:aModel},globals.HLModelCommand.klass)})},
+args: ["aModel"],
+source: "for: aModel\x0a\x09^ self new",
+messageSends: ["new"],
+referencedClasses: []
+}),
+globals.HLModelCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerConcreteClassesOn:for:",
+protocol: 'registration',
+fn: function (aBinding,aModel){
+var self=this;
+var newBinding;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._isConcrete())._and_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._isValidFor_(aModel);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+if(smalltalk.assert($1)){
+newBinding=self._registerOn_for_(aBinding,aModel);
+newBinding;
+} else {
+newBinding=aBinding;
+newBinding;
+};
+_st(self._subclasses())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._registerConcreteClassesOn_for_(newBinding,aModel);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,4)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:for:",{aBinding:aBinding,aModel:aModel,newBinding:newBinding},globals.HLModelCommand.klass)})},
+args: ["aBinding", "aModel"],
+source: "registerConcreteClassesOn: aBinding for: aModel\x0a\x09| newBinding |\x0a\x09\x0a\x09(self isConcrete and: [ self isValidFor: aModel ])\x0a\x09\x09ifTrue: [ newBinding := self registerOn: aBinding for: aModel ]\x0a\x09\x09ifFalse: [ newBinding := aBinding ].\x0a\x09\x09\x0a\x09self subclasses do: [ :each |\x0a\x09\x09each registerConcreteClassesOn: newBinding for: aModel ]",
+messageSends: ["ifTrue:ifFalse:", "and:", "isConcrete", "isValidFor:", "registerOn:for:", "do:", "subclasses", "registerConcreteClassesOn:for:"],
+referencedClasses: []
+}),
+globals.HLModelCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerOn:for:",
+protocol: 'registration',
+fn: function (aBinding,aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._for_(aModel))._registerOn_(aBinding);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"registerOn:for:",{aBinding:aBinding,aModel:aModel},globals.HLModelCommand.klass)})},
+args: ["aBinding", "aModel"],
+source: "registerOn: aBinding for: aModel\x0a\x09^ (self for: aModel) registerOn: aBinding",
+messageSends: ["registerOn:", "for:"],
+referencedClasses: []
+}),
+globals.HLModelCommand.klass);
+
+
+smalltalk.addClass('HLOpenCommand', globals.HLCommand, [], 'Helios-Commands-Core');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "o";
+},
+args: [],
+source: "key\x0a\x09^ 'o'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Open";
+},
+args: [],
+source: "label\x0a\x09^ 'Open'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenCommand.klass);
+
+
+smalltalk.addClass('HLOpenBrowserCommand', globals.HLOpenCommand, [], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLBrowser())._openAsTab();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLOpenBrowserCommand)})},
+args: [],
+source: "execute\x0a\x09^ HLBrowser openAsTab",
+messageSends: ["openAsTab"],
+referencedClasses: ["HLBrowser"]
+}),
+globals.HLOpenBrowserCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "b";
+},
+args: [],
+source: "key\x0a\x09^ 'b'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenBrowserCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Browser";
+},
+args: [],
+source: "label\x0a\x09^ 'Browser'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenBrowserCommand.klass);
+
+
+smalltalk.addClass('HLOpenSUnitCommand', globals.HLOpenCommand, [], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+function $HLSUnit(){return globals.HLSUnit||(typeof HLSUnit=="undefined"?nil:HLSUnit)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLSUnit())._openAsTab();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLOpenSUnitCommand)})},
+args: [],
+source: "execute\x0a\x09^ HLSUnit openAsTab",
+messageSends: ["openAsTab"],
+referencedClasses: ["HLSUnit"]
+}),
+globals.HLOpenSUnitCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "s";
+},
+args: [],
+source: "key\x0a\x09^ 's'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenSUnitCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "SUnit";
+},
+args: [],
+source: "label\x0a\x09^ 'SUnit'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenSUnitCommand.klass);
+
+
+smalltalk.addClass('HLOpenWorkspaceCommand', globals.HLOpenCommand, [], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+function $HLWorkspace(){return globals.HLWorkspace||(typeof HLWorkspace=="undefined"?nil:HLWorkspace)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLWorkspace())._openAsTab();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLOpenWorkspaceCommand)})},
+args: [],
+source: "execute\x0a\x09^ HLWorkspace openAsTab",
+messageSends: ["openAsTab"],
+referencedClasses: ["HLWorkspace"]
+}),
+globals.HLOpenWorkspaceCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "w";
+},
+args: [],
+source: "key\x0a\x09^ 'w'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenWorkspaceCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Workspace";
+},
+args: [],
+source: "label\x0a\x09^ 'Workspace'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLOpenWorkspaceCommand.klass);
+
+
+smalltalk.addClass('HLSwitchTabCommand', globals.HLCommand, [], 'Helios-Commands-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+var activeTab;
+function $HLTabSelectionWidget(){return globals.HLTabSelectionWidget||(typeof HLTabSelectionWidget=="undefined"?nil:HLTabSelectionWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+activeTab=self._selectedTab();
+$ctx1.sendIdx["selectedTab"]=1;
+$2=_st($HLTabSelectionWidget())._new();
+_st($2)._tabs_(self._tabs());
+_st($2)._selectedTab_(self._selectedTab());
+_st($2)._selectCallback_((function(tab){
+return smalltalk.withContext(function($ctx2) {
+return _st(tab)._activate();
+$ctx2.sendIdx["activate"]=1;
+}, function($ctx2) {$ctx2.fillBlock({tab:tab},$ctx1,1)})}));
+_st($2)._confirmCallback_((function(tab){
+return smalltalk.withContext(function($ctx2) {
+return _st(tab)._focus();
+}, function($ctx2) {$ctx2.fillBlock({tab:tab},$ctx1,2)})}));
+_st($2)._cancelCallback_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(activeTab)._activate();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+$3=_st($2)._show();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"execute",{activeTab:activeTab},globals.HLSwitchTabCommand)})},
+args: [],
+source: "execute\x0a\x09| activeTab |\x0a\x09\x0a\x09activeTab := self selectedTab.\x0a\x09\x0a\x09^ HLTabSelectionWidget new\x0a\x09\x09tabs: self tabs;\x0a\x09\x09selectedTab: self selectedTab;\x0a\x09\x09selectCallback: [ :tab | tab activate ];\x0a\x09\x09confirmCallback: [ :tab | tab focus ];\x0a\x09\x09cancelCallback: [ activeTab activate ];\x0a\x09\x09show",
+messageSends: ["selectedTab", "tabs:", "new", "tabs", "selectedTab:", "selectCallback:", "activate", "confirmCallback:", "focus", "cancelCallback:", "show"],
+referencedClasses: ["HLTabSelectionWidget"]
+}),
+globals.HLSwitchTabCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedTab",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st($HLManager())._current())._activeTab();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedTab",{},globals.HLSwitchTabCommand)})},
+args: [],
+source: "selectedTab\x0a\x09^ HLManager current activeTab",
+messageSends: ["activeTab", "current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLSwitchTabCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabs",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st($HLManager())._current())._tabs();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabs",{},globals.HLSwitchTabCommand)})},
+args: [],
+source: "tabs\x0a\x09^ HLManager current tabs",
+messageSends: ["tabs", "current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLSwitchTabCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "s";
+},
+args: [],
+source: "key\x0a\x09^ 's'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSwitchTabCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Switch tab";
+},
+args: [],
+source: "label\x0a\x09^ 'Switch tab'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSwitchTabCommand.klass);
+
+
+smalltalk.addClass('HLViewCommand', globals.HLCommand, [], 'Helios-Commands-Core');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "View";
+},
+args: [],
+source: "label\x0a\x09^ 'View'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLViewCommand.klass);
+
+});

src/Helios-Commands-Core.st

@@ -0,0 +1,345 @@
+Smalltalk createPackage: 'Helios-Commands-Core'!
+Object subclass: #HLCommand
+	instanceVariableNames: 'input'
+	package: 'Helios-Commands-Core'!
+
+!HLCommand methodsFor: 'accessing'!
+
+documentation
+	^ self class documentation
+!
+
+input
+	^ input
+!
+
+input: aString
+	^ input := aString
+!
+
+inputCompletion
+	^ #()
+!
+
+inputLabel
+	^ self label
+!
+
+key
+	^ self class key
+!
+
+keyCode
+	^ self key asUppercase charCodeAt: 1
+!
+
+label
+	^ self class label
+!
+
+menuLabel
+	^ self class menuLabel
+! !
+
+!HLCommand methodsFor: 'converting'!
+
+asActionBinding
+	^ (HLBindingAction on: self keyCode labelled: self label)
+    	command: self;
+		yourself
+!
+
+asBinding
+	^ self isBindingGroup
+		ifTrue: [ self asGroupBinding ]
+		ifFalse: [ self asActionBinding ]
+!
+
+asGroupBinding
+	^ HLBindingGroup 
+		on: self keyCode
+		labelled: self label
+! !
+
+!HLCommand methodsFor: 'defaults'!
+
+defaultInput
+	^ ''
+! !
+
+!HLCommand methodsFor: 'error handling'!
+
+commandError: aString
+	self error: aString
+! !
+
+!HLCommand methodsFor: 'executing'!
+
+execute
+! !
+
+!HLCommand methodsFor: 'registration'!
+
+registerOn: aBinding
+	^ aBinding add: self asBinding
+! !
+
+!HLCommand methodsFor: 'testing'!
+
+isAction
+	^ self isBindingGroup not
+!
+
+isActive
+	^ true
+!
+
+isBindingGroup
+	^ (self class methodDictionary includesKey: 'execute') not
+!
+
+isInputRequired
+	^ false
+! !
+
+!HLCommand class methodsFor: 'accessing'!
+
+documentation
+	^ ''
+!
+
+key
+	"Answer a single character string or nil if no key"
+	
+	^ nil
+!
+
+label
+	^ ''
+!
+
+menuLabel
+	^ self label
+!
+
+registerConcreteClassesOn: aBinding
+	| newBinding |
+	
+	self isConcrete
+		ifTrue: [ newBinding := self registerOn: aBinding ]
+		ifFalse: [ newBinding := aBinding ].
+		
+	self subclasses do: [ :each | each registerConcreteClassesOn: newBinding ]
+! !
+
+!HLCommand class methodsFor: 'registration'!
+
+concreteClasses
+	| classes |
+	
+	classes := OrderedCollection new.
+	
+	self isConcrete
+		ifTrue: [ classes add: self ].
+		
+	self subclasses do: [ :each | 
+		classes addAll: each concreteClasses ].
+		
+	^ classes
+!
+
+registerOn: aBinding
+	^ self new registerOn: aBinding
+! !
+
+!HLCommand class methodsFor: 'testing'!
+
+isConcrete
+	^ self key notNil
+!
+
+isValidFor: aModel
+	^ true
+! !
+
+HLCommand subclass: #HLCloseTabCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLCloseTabCommand methodsFor: 'executing'!
+
+execute
+	HLManager current removeActiveTab
+! !
+
+!HLCloseTabCommand class methodsFor: 'accessing'!
+
+key
+	^ 'w'
+!
+
+label
+	^ 'Close tab'
+! !
+
+HLCommand subclass: #HLModelCommand
+	instanceVariableNames: 'model'
+	package: 'Helios-Commands-Core'!
+
+!HLModelCommand methodsFor: 'accessing'!
+
+model
+	^ model
+!
+
+model: aModel
+	model := aModel
+! !
+
+!HLModelCommand class methodsFor: 'instance creation'!
+
+for: aModel
+	^ self new
+! !
+
+!HLModelCommand class methodsFor: 'registration'!
+
+registerConcreteClassesOn: aBinding for: aModel
+	| newBinding |
+	
+	(self isConcrete and: [ self isValidFor: aModel ])
+		ifTrue: [ newBinding := self registerOn: aBinding for: aModel ]
+		ifFalse: [ newBinding := aBinding ].
+		
+	self subclasses do: [ :each |
+		each registerConcreteClassesOn: newBinding for: aModel ]
+!
+
+registerOn: aBinding for: aModel
+	^ (self for: aModel) registerOn: aBinding
+! !
+
+HLCommand subclass: #HLOpenCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLOpenCommand class methodsFor: 'accessing'!
+
+key
+	^ 'o'
+!
+
+label
+	^ 'Open'
+! !
+
+HLOpenCommand subclass: #HLOpenBrowserCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLOpenBrowserCommand methodsFor: 'executing'!
+
+execute
+	^ HLBrowser openAsTab
+! !
+
+!HLOpenBrowserCommand class methodsFor: 'accessing'!
+
+key
+	^ 'b'
+!
+
+label
+	^ 'Browser'
+! !
+
+HLOpenCommand subclass: #HLOpenSUnitCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLOpenSUnitCommand methodsFor: 'executing'!
+
+execute
+	^ HLSUnit openAsTab
+! !
+
+!HLOpenSUnitCommand class methodsFor: 'accessing'!
+
+key
+	^ 's'
+!
+
+label
+	^ 'SUnit'
+! !
+
+HLOpenCommand subclass: #HLOpenWorkspaceCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLOpenWorkspaceCommand methodsFor: 'executing'!
+
+execute
+	^ HLWorkspace openAsTab
+! !
+
+!HLOpenWorkspaceCommand class methodsFor: 'accessing'!
+
+key
+	^ 'w'
+!
+
+label
+	^ 'Workspace'
+! !
+
+HLCommand subclass: #HLSwitchTabCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLSwitchTabCommand methodsFor: 'accessing'!
+
+selectedTab
+	^ HLManager current activeTab
+!
+
+tabs
+	^ HLManager current tabs
+! !
+
+!HLSwitchTabCommand methodsFor: 'executing'!
+
+execute
+	| activeTab |
+	
+	activeTab := self selectedTab.
+	
+	^ HLTabSelectionWidget new
+		tabs: self tabs;
+		selectedTab: self selectedTab;
+		selectCallback: [ :tab | tab activate ];
+		confirmCallback: [ :tab | tab focus ];
+		cancelCallback: [ activeTab activate ];
+		show
+! !
+
+!HLSwitchTabCommand class methodsFor: 'accessing'!
+
+key
+	^ 's'
+!
+
+label
+	^ 'Switch tab'
+! !
+
+HLCommand subclass: #HLViewCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Core'!
+
+!HLViewCommand class methodsFor: 'accessing'!
+
+label
+	^ 'View'
+! !
+

src/Helios-Commands-Tools.js

@@ -0,0 +1,1965 @@
+define("helios/Helios-Commands-Tools", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Commands-Core"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Commands-Tools');
+smalltalk.packages["Helios-Commands-Tools"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLToolCommand', globals.HLModelCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return nil;
+},
+args: [],
+source: "category\x0a\x09^ nil",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "for:",
+protocol: 'instance creation',
+fn: function (aToolModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._model_(aToolModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"for:",{aToolModel:aToolModel},globals.HLToolCommand.klass)})},
+args: ["aToolModel"],
+source: "for: aToolModel\x0a\x09^ self new\x0a    \x09model: aToolModel;\x0a        yourself",
+messageSends: ["model:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLToolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aModel)._isToolModel();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLToolCommand.klass)})},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ aModel isToolModel",
+messageSends: ["isToolModel"],
+referencedClasses: []
+}),
+globals.HLToolCommand.klass);
+
+
+smalltalk.addClass('HLBrowseMethodCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "browse method";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'browse method'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowseMethodCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._openMethod();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLBrowseMethodCommand)})},
+args: [],
+source: "execute\x0a\x09self model openMethod",
+messageSends: ["openMethod", "model"],
+referencedClasses: []
+}),
+globals.HLBrowseMethodCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aModel)._isReferencesModel();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowseMethodCommand.klass)})},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ aModel isReferencesModel",
+messageSends: ["isReferencesModel"],
+referencedClasses: []
+}),
+globals.HLBrowseMethodCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "b";
+},
+args: [],
+source: "key\x0a\x09^ 'b'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowseMethodCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "browse method";
+},
+args: [],
+source: "label\x0a\x09^ 'browse method'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowseMethodCommand.klass);
+
+
+smalltalk.addClass('HLCommitPackageCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Packages";
+},
+args: [],
+source: "category\x0a\x09^ 'Packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommitPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commitPackage",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._commitPackageOnSuccess_onError_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._informSuccess();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}),(function(error){
+return smalltalk.withContext(function($ctx2) {
+return self._onPackageCommitError_(error);
+}, function($ctx2) {$ctx2.fillBlock({error:error},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"commitPackage",{},globals.HLCommitPackageCommand)})},
+args: [],
+source: "commitPackage\x0a\x09self model \x0a\x09\x09commitPackageOnSuccess: [ self informSuccess ]\x0a\x09\x09onError: [ :error | self onPackageCommitError: error ]",
+messageSends: ["commitPackageOnSuccess:onError:", "model", "informSuccess", "onPackageCommitError:"],
+referencedClasses: []
+}),
+globals.HLCommitPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._commitPackage();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCommitPackageCommand)})},
+args: [],
+source: "execute\x0a\x09self commitPackage",
+messageSends: ["commitPackage"],
+referencedClasses: []
+}),
+globals.HLCommitPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "informSuccess",
+protocol: 'executing',
+fn: function (){
+var self=this;
+function $HLInformationWidget(){return globals.HLInformationWidget||(typeof HLInformationWidget=="undefined"?nil:HLInformationWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLInformationWidget())._new();
+_st($1)._informationString_("Commit successful!");
+$2=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"informSuccess",{},globals.HLCommitPackageCommand)})},
+args: [],
+source: "informSuccess\x0a\x09HLInformationWidget new\x0a\x09\x09informationString: 'Commit successful!';\x0a\x09\x09show",
+messageSends: ["informationString:", "new", "show"],
+referencedClasses: ["HLInformationWidget"]
+}),
+globals.HLCommitPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isActive\x0a\x09^ true\x0a\x09\x22self model isPackageDirty\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommitPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageCommitError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+function $HLPackageCommitErrorHelper(){return globals.HLPackageCommitErrorHelper||(typeof HLPackageCommitErrorHelper=="undefined"?nil:HLPackageCommitErrorHelper)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLPackageCommitErrorHelper())._on_(self._model()))._showHelp();
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageCommitError:",{anError:anError},globals.HLCommitPackageCommand)})},
+args: ["anError"],
+source: "onPackageCommitError: anError\x0a\x09(HLPackageCommitErrorHelper on: self model)\x0a\x09\x09showHelp",
+messageSends: ["showHelp", "on:", "model"],
+referencedClasses: ["HLPackageCommitErrorHelper"]
+}),
+globals.HLCommitPackageCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "k";
+},
+args: [],
+source: "key\x0a\x09^ 'k'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommitPackageCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Commit package";
+},
+args: [],
+source: "label\x0a\x09^ 'Commit package'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCommitPackageCommand.klass);
+
+
+smalltalk.addClass('HLCopyCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Copy";
+},
+args: [],
+source: "label\x0a\x09^ 'Copy'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyCommand.klass);
+
+
+smalltalk.addClass('HLCopyClassCommand', globals.HLCopyCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "category\x0a\x09^ 'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultInput",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLCopyClassCommand)})},
+args: [],
+source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
+messageSends: ["name", "theNonMetaClass", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "New class name:";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'New class name:'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._copyClassTo_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCopyClassCommand)})},
+args: [],
+source: "execute\x0a\x09self model copyClassTo: self input",
+messageSends: ["copyClassTo:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLCopyClassCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedClass notNil",
+messageSends: ["notNil", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Copy class";
+},
+args: [],
+source: "label\x0a\x09^ 'Copy class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Copy class...";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Copy class...'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCopyClassCommand.klass);
+
+
+smalltalk.addClass('HLFindCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "f";
+},
+args: [],
+source: "key\x0a\x09^ 'f'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Find";
+},
+args: [],
+source: "label\x0a\x09^ 'Find'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindCommand.klass);
+
+
+smalltalk.addClass('HLFindClassCommand', globals.HLFindCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "select a class";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'select a class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._openClassNamed_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLFindClassCommand)})},
+args: [],
+source: "execute\x0a\x09self model openClassNamed: self input",
+messageSends: ["openClassNamed:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLFindClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._availableClassNames();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLFindClassCommand)})},
+args: [],
+source: "inputCompletion\x0a\x09^ self model availableClassNames",
+messageSends: ["availableClassNames", "model"],
+referencedClasses: []
+}),
+globals.HLFindClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Find a class";
+},
+args: [],
+source: "inputLabel\x0a\x09^ 'Find a class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindClassCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+return true;
+},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Find class";
+},
+args: [],
+source: "label\x0a\x09^ 'Find class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindClassCommand.klass);
+
+
+smalltalk.addClass('HLFindReferencesCommand', globals.HLFindCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultInput",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$4,$1,$receiver;
+$3=self._model();
+$ctx1.sendIdx["model"]=1;
+$2=_st($3)._selectedMethod();
+if(($receiver = $2) == null || $receiver.isNil){
+$4=_st(self._model())._selectedClass();
+if(($receiver = $4) == null || $receiver.isNil){
+$1="";
+} else {
+var class_;
+class_=$receiver;
+$1=_st(_st(class_)._theNonMetaClass())._name();
+};
+} else {
+var method;
+method=$receiver;
+$1=_st(method)._selector();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLFindReferencesCommand)})},
+args: [],
+source: "defaultInput\x0a\x09^ self model selectedMethod \x0a\x09\x09ifNil: [\x0a\x09\x09\x09self model selectedClass\x0a\x09\x09\x09\x09ifNil: [ '' ]\x0a\x09\x09\x09\x09ifNotNil: [ :class | class theNonMetaClass name ] ]\x0a\x09\x09ifNotNil: [ :method | method selector ]",
+messageSends: ["ifNil:ifNotNil:", "selectedMethod", "model", "selectedClass", "name", "theNonMetaClass", "selector"],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "find references";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'find references'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+function $HLReferences(){return globals.HLReferences||(typeof HLReferences=="undefined"?nil:HLReferences)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLReferences())._new();
+_st($1)._openAsTab();
+$2=_st($1)._search_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLFindReferencesCommand)})},
+args: [],
+source: "execute\x0a\x09HLReferences new \x0a\x09\x09openAsTab;\x0a\x09\x09search: self input",
+messageSends: ["openAsTab", "new", "search:", "input"],
+referencedClasses: ["HLReferences"]
+}),
+globals.HLFindReferencesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1;
+$3=self._model();
+$ctx1.sendIdx["model"]=1;
+$2=_st($3)._availableClassNames();
+$1=_st($2).__comma(_st(self._model())._allSelectors());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLFindReferencesCommand)})},
+args: [],
+source: "inputCompletion\x0a\x09^ self model availableClassNames, self model allSelectors",
+messageSends: [",", "availableClassNames", "model", "allSelectors"],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Find references of";
+},
+args: [],
+source: "inputLabel\x0a\x09^ 'Find references of'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "r";
+},
+args: [],
+source: "key\x0a\x09^ 'r'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Find references";
+},
+args: [],
+source: "label\x0a\x09^ 'Find references'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFindReferencesCommand.klass);
+
+
+smalltalk.addClass('HLMoveToCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "m";
+},
+args: [],
+source: "key\x0a\x09^ 'm'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveToCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move";
+},
+args: [],
+source: "label\x0a\x09^ 'Move'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveToCommand.klass);
+
+
+smalltalk.addClass('HLMoveClassToCommand', globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLMoveClassToCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedClass notNil",
+messageSends: ["notNil", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLMoveClassToCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move class";
+},
+args: [],
+source: "label\x0a\x09^ 'Move class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToCommand.klass);
+
+
+smalltalk.addClass('HLMoveClassToPackageCommand', globals.HLMoveClassToCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "category\x0a\x09^ 'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "select a package";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'select a package'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._moveClassToPackage_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveClassToPackageCommand)})},
+args: [],
+source: "execute\x0a\x09self model moveClassToPackage: self input",
+messageSends: ["moveClassToPackage:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._availablePackageNames();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveClassToPackageCommand)})},
+args: [],
+source: "inputCompletion\x0a\x09^ self model availablePackageNames",
+messageSends: ["availablePackageNames", "model"],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move class to package:";
+},
+args: [],
+source: "inputLabel\x0a\x09^ 'Move class to package:'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "p";
+},
+args: [],
+source: "key\x0a\x09^ 'p'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move class to package";
+},
+args: [],
+source: "label\x0a\x09^ 'Move class to package'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move to package...";
+},
+args: [],
+source: "menuLabel\x09\x0a\x09^ 'Move to package...'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveClassToPackageCommand.klass);
+
+
+smalltalk.addClass('HLMoveMethodToCommand', globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Methods";
+},
+args: [],
+source: "category\x0a\x09^ 'Methods'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedMethod())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLMoveMethodToCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedMethod notNil",
+messageSends: ["notNil", "selectedMethod", "model"],
+referencedClasses: []
+}),
+globals.HLMoveMethodToCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "m";
+},
+args: [],
+source: "key\x0a\x09^ 'm'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move method";
+},
+args: [],
+source: "label\x0a\x09^ 'Move method'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToCommand.klass);
+
+
+smalltalk.addClass('HLMoveMethodToClassCommand', globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "select a class";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'select a class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._moveMethodToClass_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveMethodToClassCommand)})},
+args: [],
+source: "execute\x0a\x09self model moveMethodToClass: self input",
+messageSends: ["moveMethodToClass:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._availableClassNames();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveMethodToClassCommand)})},
+args: [],
+source: "inputCompletion\x0a\x09^ self model availableClassNames",
+messageSends: ["availableClassNames", "model"],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move method to class:";
+},
+args: [],
+source: "inputLabel\x0a\x09^ 'Move method to class:'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move method to class";
+},
+args: [],
+source: "label\x09\x0a\x09^ 'Move method to class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move to class...";
+},
+args: [],
+source: "menuLabel\x09\x0a\x09^ 'Move to class...'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToClassCommand.klass);
+
+
+smalltalk.addClass('HLMoveMethodToProtocolCommand', globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "select a protocol";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'select a protocol'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._moveMethodToProtocol_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveMethodToProtocolCommand)})},
+args: [],
+source: "execute\x0a\x09self model moveMethodToProtocol: self input",
+messageSends: ["moveMethodToProtocol:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._availableProtocols();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveMethodToProtocolCommand)})},
+args: [],
+source: "inputCompletion\x0a\x09^ self model availableProtocols",
+messageSends: ["availableProtocols", "model"],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move method to a protocol:";
+},
+args: [],
+source: "inputLabel\x0a\x09^ 'Move method to a protocol:'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "t";
+},
+args: [],
+source: "key\x0a\x09^ 't'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move method to protocol";
+},
+args: [],
+source: "label\x0a\x09^ 'Move method to protocol'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Move to protocol...";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Move to protocol...'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMoveMethodToProtocolCommand.klass);
+
+
+smalltalk.addClass('HLRemoveCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "x";
+},
+args: [],
+source: "key\x0a\x09^ 'x'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove";
+},
+args: [],
+source: "label\x0a\x09^ 'Remove'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveCommand.klass);
+
+
+smalltalk.addClass('HLRemoveClassCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "category\x0a\x09^ 'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._removeClass();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveClassCommand)})},
+args: [],
+source: "execute\x0a\x09self model removeClass",
+messageSends: ["removeClass", "model"],
+referencedClasses: []
+}),
+globals.HLRemoveClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveClassCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedClass notNil",
+messageSends: ["notNil", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLRemoveClassCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove class";
+},
+args: [],
+source: "label\x0a\x09^ 'Remove class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove class";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Remove class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveClassCommand.klass);
+
+
+smalltalk.addClass('HLRemoveMethodCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Methods";
+},
+args: [],
+source: "category\x0a\x09^ 'Methods'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveMethodCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._removeMethod();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveMethodCommand)})},
+args: [],
+source: "execute\x0a\x09self model removeMethod",
+messageSends: ["removeMethod", "model"],
+referencedClasses: []
+}),
+globals.HLRemoveMethodCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedMethod())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveMethodCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedMethod notNil",
+messageSends: ["notNil", "selectedMethod", "model"],
+referencedClasses: []
+}),
+globals.HLRemoveMethodCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "m";
+},
+args: [],
+source: "key\x0a\x09^ 'm'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveMethodCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove method";
+},
+args: [],
+source: "label\x0a\x09^ 'Remove method'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveMethodCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove method";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Remove method'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveMethodCommand.klass);
+
+
+smalltalk.addClass('HLRemoveProtocolCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Protocols";
+},
+args: [],
+source: "category\x0a\x09^ 'Protocols'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._removeProtocol();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveProtocolCommand)})},
+args: [],
+source: "execute\x0a\x09self model removeProtocol",
+messageSends: ["removeProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLRemoveProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedProtocol())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveProtocolCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedProtocol notNil",
+messageSends: ["notNil", "selectedProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLRemoveProtocolCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "t";
+},
+args: [],
+source: "key\x0a\x09^ 't'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveProtocolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove protocol";
+},
+args: [],
+source: "label\x0a\x09^ 'Remove protocol'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveProtocolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Remove protocol";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Remove protocol'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRemoveProtocolCommand.klass);
+
+
+smalltalk.addClass('HLRenameCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "r";
+},
+args: [],
+source: "key\x0a\x09^ 'r'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename";
+},
+args: [],
+source: "label\x0a\x09^ 'Rename'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameCommand.klass);
+
+
+smalltalk.addClass('HLRenameClassCommand', globals.HLRenameCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "category\x0a\x09^ 'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultInput",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLRenameClassCommand)})},
+args: [],
+source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
+messageSends: ["name", "theNonMetaClass", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename class to:";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'Rename class to:'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._renameClassTo_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRenameClassCommand)})},
+args: [],
+source: "execute\x0a\x09self model renameClassTo: self input",
+messageSends: ["renameClassTo:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedClass())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRenameClassCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedClass notNil",
+messageSends: ["notNil", "selectedClass", "model"],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename class";
+},
+args: [],
+source: "label\x0a\x09^ 'Rename class'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename class...";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Rename class...'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameClassCommand.klass);
+
+
+smalltalk.addClass('HLRenameProtocolCommand', globals.HLRenameCommand, [], 'Helios-Commands-Tools');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Protocols";
+},
+args: [],
+source: "category\x0a\x09^ 'Protocols'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultInput",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._selectedProtocol();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLRenameProtocolCommand)})},
+args: [],
+source: "defaultInput\x0a\x09^ self model selectedProtocol",
+messageSends: ["selectedProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename protocol to:";
+},
+args: [],
+source: "displayLabel\x0a\x09^ 'Rename protocol to:'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._renameProtocolTo_(self._input());
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRenameProtocolCommand)})},
+args: [],
+source: "execute\x0a\x09self model renameProtocolTo: self input",
+messageSends: ["renameProtocolTo:", "model", "input"],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._selectedProtocol())._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRenameProtocolCommand)})},
+args: [],
+source: "isActive\x0a\x09^ self model selectedProtocol notNil",
+messageSends: ["notNil", "selectedProtocol", "model"],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isInputRequired",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isInputRequired\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "t";
+},
+args: [],
+source: "key\x0a\x09^ 't'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename protocol";
+},
+args: [],
+source: "label\x0a\x09^ 'Rename protocol'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Rename protocol...";
+},
+args: [],
+source: "menuLabel\x0a\x09^ 'Rename protocol...'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRenameProtocolCommand.klass);
+
+});

src/Helios-Commands-Tools.st

@@ -0,0 +1,718 @@
+Smalltalk createPackage: 'Helios-Commands-Tools'!
+HLModelCommand subclass: #HLToolCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLToolCommand methodsFor: 'accessing'!
+
+category
+	^ nil
+! !
+
+!HLToolCommand class methodsFor: 'instance creation'!
+
+for: aToolModel
+	^ self new
+    	model: aToolModel;
+        yourself
+! !
+
+!HLToolCommand class methodsFor: 'testing'!
+
+isValidFor: aModel
+	^ aModel isToolModel
+! !
+
+HLToolCommand subclass: #HLBrowseMethodCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLBrowseMethodCommand methodsFor: 'accessing'!
+
+displayLabel
+	^ 'browse method'
+! !
+
+!HLBrowseMethodCommand methodsFor: 'executing'!
+
+execute
+	self model openMethod
+! !
+
+!HLBrowseMethodCommand class methodsFor: 'accessing'!
+
+key
+	^ 'b'
+!
+
+label
+	^ 'browse method'
+! !
+
+!HLBrowseMethodCommand class methodsFor: 'testing'!
+
+isValidFor: aModel
+	^ aModel isReferencesModel
+! !
+
+HLToolCommand subclass: #HLCommitPackageCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLCommitPackageCommand methodsFor: 'accessing'!
+
+category
+	^ 'Packages'
+! !
+
+!HLCommitPackageCommand methodsFor: 'error handling'!
+
+onPackageCommitError: anError
+	(HLPackageCommitErrorHelper on: self model)
+		showHelp
+! !
+
+!HLCommitPackageCommand methodsFor: 'executing'!
+
+commitPackage
+	self model 
+		commitPackageOnSuccess: [ self informSuccess ]
+		onError: [ :error | self onPackageCommitError: error ]
+!
+
+execute
+	self commitPackage
+!
+
+informSuccess
+	HLInformationWidget new
+		informationString: 'Commit successful!!';
+		show
+! !
+
+!HLCommitPackageCommand methodsFor: 'testing'!
+
+isActive
+	^ true
+	"self model isPackageDirty"
+! !
+
+!HLCommitPackageCommand class methodsFor: 'accessing'!
+
+key
+	^ 'k'
+!
+
+label
+	^ 'Commit package'
+! !
+
+HLToolCommand subclass: #HLCopyCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLCopyCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Copy'
+! !
+
+HLCopyCommand subclass: #HLCopyClassCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLCopyClassCommand methodsFor: 'accessing'!
+
+category
+	^ 'Classes'
+!
+
+displayLabel
+	^ 'New class name:'
+! !
+
+!HLCopyClassCommand methodsFor: 'defaults'!
+
+defaultInput
+	^ self model selectedClass theNonMetaClass name
+! !
+
+!HLCopyClassCommand methodsFor: 'executing'!
+
+execute
+	self model copyClassTo: self input
+! !
+
+!HLCopyClassCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedClass notNil
+!
+
+isInputRequired
+	^ true
+! !
+
+!HLCopyClassCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Copy class'
+!
+
+menuLabel
+	^ 'Copy class...'
+! !
+
+HLToolCommand subclass: #HLFindCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLFindCommand class methodsFor: 'accessing'!
+
+key
+	^ 'f'
+!
+
+label
+	^ 'Find'
+! !
+
+HLFindCommand subclass: #HLFindClassCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLFindClassCommand methodsFor: 'accessing'!
+
+displayLabel
+	^ 'select a class'
+!
+
+inputCompletion
+	^ self model availableClassNames
+!
+
+inputLabel
+	^ 'Find a class'
+! !
+
+!HLFindClassCommand methodsFor: 'executing'!
+
+execute
+	self model openClassNamed: self input
+! !
+
+!HLFindClassCommand methodsFor: 'testing'!
+
+isInputRequired
+	^ true
+! !
+
+!HLFindClassCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Find class'
+! !
+
+!HLFindClassCommand class methodsFor: 'testing'!
+
+isValidFor: aModel
+	^ true
+! !
+
+HLFindCommand subclass: #HLFindReferencesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLFindReferencesCommand methodsFor: 'accessing'!
+
+displayLabel
+	^ 'find references'
+!
+
+inputCompletion
+	^ self model availableClassNames, self model allSelectors
+!
+
+inputLabel
+	^ 'Find references of'
+! !
+
+!HLFindReferencesCommand methodsFor: 'defaults'!
+
+defaultInput
+	^ self model selectedMethod 
+		ifNil: [
+			self model selectedClass
+				ifNil: [ '' ]
+				ifNotNil: [ :class | class theNonMetaClass name ] ]
+		ifNotNil: [ :method | method selector ]
+! !
+
+!HLFindReferencesCommand methodsFor: 'executing'!
+
+execute
+	HLReferences new 
+		openAsTab;
+		search: self input
+! !
+
+!HLFindReferencesCommand methodsFor: 'testing'!
+
+isInputRequired
+	^ true
+! !
+
+!HLFindReferencesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'r'
+!
+
+label
+	^ 'Find references'
+! !
+
+HLToolCommand subclass: #HLMoveToCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLMoveToCommand class methodsFor: 'accessing'!
+
+key
+	^ 'm'
+!
+
+label
+	^ 'Move'
+! !
+
+HLMoveToCommand subclass: #HLMoveClassToCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLMoveClassToCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedClass notNil
+! !
+
+!HLMoveClassToCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Move class'
+! !
+
+HLMoveClassToCommand subclass: #HLMoveClassToPackageCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLMoveClassToPackageCommand methodsFor: 'accessing'!
+
+category
+	^ 'Classes'
+!
+
+displayLabel
+	^ 'select a package'
+!
+
+inputCompletion
+	^ self model availablePackageNames
+!
+
+inputLabel
+	^ 'Move class to package:'
+! !
+
+!HLMoveClassToPackageCommand methodsFor: 'executing'!
+
+execute
+	self model moveClassToPackage: self input
+! !
+
+!HLMoveClassToPackageCommand methodsFor: 'testing'!
+
+isInputRequired
+	^ true
+! !
+
+!HLMoveClassToPackageCommand class methodsFor: 'accessing'!
+
+key
+	^ 'p'
+!
+
+label
+	^ 'Move class to package'
+!
+
+menuLabel	
+	^ 'Move to package...'
+! !
+
+HLMoveToCommand subclass: #HLMoveMethodToCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLMoveMethodToCommand methodsFor: 'accessing'!
+
+category
+	^ 'Methods'
+! !
+
+!HLMoveMethodToCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedMethod notNil
+! !
+
+!HLMoveMethodToCommand class methodsFor: 'accessing'!
+
+key
+	^ 'm'
+!
+
+label
+	^ 'Move method'
+! !
+
+HLMoveMethodToCommand subclass: #HLMoveMethodToClassCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLMoveMethodToClassCommand methodsFor: 'accessing'!
+
+displayLabel
+	^ 'select a class'
+!
+
+inputCompletion
+	^ self model availableClassNames
+!
+
+inputLabel
+	^ 'Move method to class:'
+! !
+
+!HLMoveMethodToClassCommand methodsFor: 'executing'!
+
+execute
+	self model moveMethodToClass: self input
+! !
+
+!HLMoveMethodToClassCommand methodsFor: 'testing'!
+
+isInputRequired
+	^ true
+! !
+
+!HLMoveMethodToClassCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label	
+	^ 'Move method to class'
+!
+
+menuLabel	
+	^ 'Move to class...'
+! !
+
+HLMoveMethodToCommand subclass: #HLMoveMethodToProtocolCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLMoveMethodToProtocolCommand methodsFor: 'accessing'!
+
+displayLabel
+	^ 'select a protocol'
+!
+
+inputCompletion
+	^ self model availableProtocols
+!
+
+inputLabel
+	^ 'Move method to a protocol:'
+! !
+
+!HLMoveMethodToProtocolCommand methodsFor: 'executing'!
+
+execute
+	self model moveMethodToProtocol: self input
+! !
+
+!HLMoveMethodToProtocolCommand methodsFor: 'testing'!
+
+isInputRequired
+	^ true
+! !
+
+!HLMoveMethodToProtocolCommand class methodsFor: 'accessing'!
+
+key
+	^ 't'
+!
+
+label
+	^ 'Move method to protocol'
+!
+
+menuLabel
+	^ 'Move to protocol...'
+! !
+
+HLToolCommand subclass: #HLRemoveCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRemoveCommand class methodsFor: 'accessing'!
+
+key
+	^ 'x'
+!
+
+label
+	^ 'Remove'
+! !
+
+HLRemoveCommand subclass: #HLRemoveClassCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRemoveClassCommand methodsFor: 'accessing'!
+
+category
+	^ 'Classes'
+! !
+
+!HLRemoveClassCommand methodsFor: 'executing'!
+
+execute
+	self model removeClass
+! !
+
+!HLRemoveClassCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedClass notNil
+! !
+
+!HLRemoveClassCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Remove class'
+!
+
+menuLabel
+	^ 'Remove class'
+! !
+
+HLRemoveCommand subclass: #HLRemoveMethodCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRemoveMethodCommand methodsFor: 'accessing'!
+
+category
+	^ 'Methods'
+! !
+
+!HLRemoveMethodCommand methodsFor: 'executing'!
+
+execute
+	self model removeMethod
+! !
+
+!HLRemoveMethodCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedMethod notNil
+! !
+
+!HLRemoveMethodCommand class methodsFor: 'accessing'!
+
+key
+	^ 'm'
+!
+
+label
+	^ 'Remove method'
+!
+
+menuLabel
+	^ 'Remove method'
+! !
+
+HLRemoveCommand subclass: #HLRemoveProtocolCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRemoveProtocolCommand methodsFor: 'accessing'!
+
+category
+	^ 'Protocols'
+! !
+
+!HLRemoveProtocolCommand methodsFor: 'executing'!
+
+execute
+	self model removeProtocol
+! !
+
+!HLRemoveProtocolCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedProtocol notNil
+! !
+
+!HLRemoveProtocolCommand class methodsFor: 'accessing'!
+
+key
+	^ 't'
+!
+
+label
+	^ 'Remove protocol'
+!
+
+menuLabel
+	^ 'Remove protocol'
+! !
+
+HLToolCommand subclass: #HLRenameCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRenameCommand class methodsFor: 'accessing'!
+
+key
+	^ 'r'
+!
+
+label
+	^ 'Rename'
+! !
+
+HLRenameCommand subclass: #HLRenameClassCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRenameClassCommand methodsFor: 'accessing'!
+
+category
+	^ 'Classes'
+!
+
+displayLabel
+	^ 'Rename class to:'
+! !
+
+!HLRenameClassCommand methodsFor: 'defaults'!
+
+defaultInput
+	^ self model selectedClass theNonMetaClass name
+! !
+
+!HLRenameClassCommand methodsFor: 'executing'!
+
+execute
+	self model renameClassTo: self input
+! !
+
+!HLRenameClassCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedClass notNil
+!
+
+isInputRequired
+	^ true
+! !
+
+!HLRenameClassCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Rename class'
+!
+
+menuLabel
+	^ 'Rename class...'
+! !
+
+HLRenameCommand subclass: #HLRenameProtocolCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-Tools'!
+
+!HLRenameProtocolCommand methodsFor: 'accessing'!
+
+category
+	^ 'Protocols'
+!
+
+displayLabel
+	^ 'Rename protocol to:'
+! !
+
+!HLRenameProtocolCommand methodsFor: 'defaults'!
+
+defaultInput
+	^ self model selectedProtocol
+! !
+
+!HLRenameProtocolCommand methodsFor: 'executing'!
+
+execute
+	self model renameProtocolTo: self input
+! !
+
+!HLRenameProtocolCommand methodsFor: 'testing'!
+
+isActive
+	^ self model selectedProtocol notNil
+!
+
+isInputRequired
+	^ true
+! !
+
+!HLRenameProtocolCommand class methodsFor: 'accessing'!
+
+key
+	^ 't'
+!
+
+label
+	^ 'Rename protocol'
+!
+
+menuLabel
+	^ 'Rename protocol...'
+! !
+

src/Helios-Core.js

@@ -0,0 +1,6966 @@
+define("helios/Helios-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Infrastructure", "amber_core/Kernel-Objects", "amber_core/Web"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Core');
+smalltalk.packages["Helios-Core"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLModel', globals.InterfacingObject, ['announcer', 'environment'], 'Helios-Core');
+globals.HLModel.comment="I am the abstract superclass of all models of Helios.\x0aI am the \x22Model\x22 part of the MVC pattern implementation in Helios.\x0a\x0aI provide access to an `Environment` object and both a local (model-specific) and global (system-specific) announcer.\x0a\x0aThe `#withChangesDo:` method is handy for performing model changes ensuring that all widgets are aware of the change and can prevent it from happening.\x0a\x0aModifications of the system should be done via commands (see `HLCommand` and subclasses).";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "announcer",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Announcer(){return globals.Announcer||(typeof Announcer=="undefined"?nil:Announcer)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@announcer"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@announcer"]=_st($Announcer())._new();
+$1=self["@announcer"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"announcer",{},globals.HLModel)})},
+args: [],
+source: "announcer\x0a\x09^ announcer ifNil: [ announcer := Announcer new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["Announcer"]
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@environment"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=_st(self._manager())._environment();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"environment",{},globals.HLModel)})},
+args: [],
+source: "environment\x0a\x09^ environment ifNil: [ self manager environment ]",
+messageSends: ["ifNil:", "environment", "manager"],
+referencedClasses: []
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment:",
+protocol: 'accessing',
+fn: function (anEnvironment){
+var self=this;
+self["@environment"]=anEnvironment;
+return self},
+args: ["anEnvironment"],
+source: "environment: anEnvironment\x0a\x09environment := anEnvironment",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isBrowserModel",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "isBrowserModel\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isReferencesModel",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "isReferencesModel\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isToolModel",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "isToolModel\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "manager",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLManager())._current();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"manager",{},globals.HLModel)})},
+args: [],
+source: "manager\x0a\x09^ HLManager current",
+messageSends: ["current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "systemAnnouncer",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._systemAnnouncer();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"systemAnnouncer",{},globals.HLModel)})},
+args: [],
+source: "systemAnnouncer\x0a\x09^ self environment systemAnnouncer",
+messageSends: ["systemAnnouncer", "environment"],
+referencedClasses: []
+}),
+globals.HLModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "withChangesDo:",
+protocol: 'error handling',
+fn: function (aBlock){
+var self=this;
+function $HLAboutToChange(){return globals.HLAboutToChange||(typeof HLAboutToChange=="undefined"?nil:HLAboutToChange)}
+function $HLChangeForbidden(){return globals.HLChangeForbidden||(typeof HLChangeForbidden=="undefined"?nil:HLChangeForbidden)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+$1=_st($HLAboutToChange())._new();
+_st($1)._actionBlock_(aBlock);
+$2=_st($1)._yourself();
+_st(self._announcer())._announce_($2);
+return _st(aBlock)._value();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._on_do_($HLChangeForbidden(),(function(ex){
+}));
+return self}, function($ctx1) {$ctx1.fill(self,"withChangesDo:",{aBlock:aBlock},globals.HLModel)})},
+args: ["aBlock"],
+source: "withChangesDo: aBlock\x0a\x09[ \x0a\x09\x09self announcer announce: (HLAboutToChange new\x0a\x09\x09\x09actionBlock: aBlock;\x0a\x09\x09\x09yourself).\x0a\x09\x09aBlock value.\x0a\x09]\x0a\x09\x09on: HLChangeForbidden \x0a\x09\x09do: [ :ex | ]",
+messageSends: ["on:do:", "announce:", "announcer", "actionBlock:", "new", "yourself", "value"],
+referencedClasses: ["HLAboutToChange", "HLChangeForbidden"]
+}),
+globals.HLModel);
+
+
+
+smalltalk.addClass('HLFinder', globals.HLModel, [], 'Helios-Core');
+globals.HLFinder.comment="I am the `Finder` service handler of Helios.\x0a\x0aFinding a class will open a new class browser, while finding a method will open a references browser.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "findClass:",
+protocol: 'finding',
+fn: function (aClass){
+var self=this;
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLBrowser())._openAsTab())._openClassNamed_(_st(aClass)._name());
+return self}, function($ctx1) {$ctx1.fill(self,"findClass:",{aClass:aClass},globals.HLFinder)})},
+args: ["aClass"],
+source: "findClass: aClass\x0a\x09HLBrowser openAsTab openClassNamed: aClass name",
+messageSends: ["openClassNamed:", "openAsTab", "name"],
+referencedClasses: ["HLBrowser"]
+}),
+globals.HLFinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "findMethod:",
+protocol: 'finding',
+fn: function (aCompiledMethod){
+var self=this;
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLBrowser())._openAsTab())._openMethod_(aCompiledMethod);
+return self}, function($ctx1) {$ctx1.fill(self,"findMethod:",{aCompiledMethod:aCompiledMethod},globals.HLFinder)})},
+args: ["aCompiledMethod"],
+source: "findMethod: aCompiledMethod\x0a\x09HLBrowser openAsTab openMethod: aCompiledMethod",
+messageSends: ["openMethod:", "openAsTab"],
+referencedClasses: ["HLBrowser"]
+}),
+globals.HLFinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "findString:",
+protocol: 'finding',
+fn: function (aString){
+var self=this;
+var foundClass;
+function $HLReferences(){return globals.HLReferences||(typeof HLReferences=="undefined"?nil:HLReferences)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+foundClass=_st(_st(self._environment())._classes())._detect_ifNone_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._name()).__eq(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){
+return nil;
+}));
+$1=foundClass;
+if(($receiver = $1) == null || $receiver.isNil){
+_st(_st($HLReferences())._openAsTab())._search_(aString);
+} else {
+self._findClass_(foundClass);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"findString:",{aString:aString,foundClass:foundClass},globals.HLFinder)})},
+args: ["aString"],
+source: "findString: aString\x0a\x09| foundClass |\x0a\x09\x0a\x09foundClass := self environment classes \x0a\x09\x09detect: [ :each | each name = aString ]\x0a\x09\x09ifNone: [ nil ].\x0a\x09\x0a\x09foundClass \x0a\x09\x09ifNil: [ HLReferences openAsTab search: aString ]\x0a\x09\x09ifNotNil: [ self findClass: foundClass ]",
+messageSends: ["detect:ifNone:", "classes", "environment", "=", "name", "ifNil:ifNotNil:", "search:", "openAsTab", "findClass:"],
+referencedClasses: ["HLReferences"]
+}),
+globals.HLFinder);
+
+
+
+smalltalk.addClass('HLToolModel', globals.HLModel, ['selectedClass', 'selectedPackage', 'selectedProtocol', 'selectedSelector'], 'Helios-Core');
+globals.HLToolModel.comment="I am a model specific to package and class manipulation. All browsers should either use me or a subclass as their model.\x0a\x0aI provide methods for package, class, protocol and method manipulation and access, forwarding to my environment.\x0a\x0aI also handle compilation of classes and methods as well as compilation and parsing errors.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addInstVarNamed:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $HLInstVarAdded(){return globals.HLInstVarAdded||(typeof HLInstVarAdded=="undefined"?nil:HLInstVarAdded)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4;
+$1=self._environment();
+$2=self._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+_st($1)._addInstVarNamed_to_(aString,$2);
+$3=_st($HLInstVarAdded())._new();
+_st($3)._theClass_(self._selectedClass());
+_st($3)._variableName_(aString);
+$4=_st($3)._yourself();
+_st(self._announcer())._announce_($4);
+return self}, function($ctx1) {$ctx1.fill(self,"addInstVarNamed:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+source: "addInstVarNamed: aString\x0a\x09self environment addInstVarNamed: aString to: self selectedClass.\x0a\x09self announcer announce: (HLInstVarAdded new\x0a\x09\x09theClass: self selectedClass;\x0a\x09\x09variableName: aString;\x0a\x09\x09yourself)",
+messageSends: ["addInstVarNamed:to:", "environment", "selectedClass", "announce:", "announcer", "theClass:", "new", "variableName:", "yourself"],
+referencedClasses: ["HLInstVarAdded"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "allProtocol",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return "-- all --";
+},
+args: [],
+source: "allProtocol\x0a\x09^ '-- all --'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "allSelectors",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._allSelectors();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"allSelectors",{},globals.HLToolModel)})},
+args: [],
+source: "allSelectors\x0a\x09^ self environment allSelectors",
+messageSends: ["allSelectors", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "availableClassNames",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._availableClassNames();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"availableClassNames",{},globals.HLToolModel)})},
+args: [],
+source: "availableClassNames\x0a\x09^ self environment availableClassNames",
+messageSends: ["availableClassNames", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "availablePackageNames",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._availablePackageNames();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"availablePackageNames",{},globals.HLToolModel)})},
+args: [],
+source: "availablePackageNames\x0a\x09^ self environment availablePackageNames",
+messageSends: ["availablePackageNames", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "availablePackages",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._availablePackageNames();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"availablePackages",{},globals.HLToolModel)})},
+args: [],
+source: "availablePackages\x0a\x09^ self environment availablePackageNames",
+messageSends: ["availablePackageNames", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "availableProtocols",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._availableProtocolsFor_(self._selectedClass());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"availableProtocols",{},globals.HLToolModel)})},
+args: [],
+source: "availableProtocols\x0a\x09^ self environment availableProtocolsFor: self selectedClass",
+messageSends: ["availableProtocolsFor:", "environment", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commitPackageOnSuccess:onError:",
+protocol: 'commands actions',
+fn: function (aBlock,anotherBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._commitPackage_onSuccess_onError_(self._packageToCommit(),aBlock,anotherBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"commitPackageOnSuccess:onError:",{aBlock:aBlock,anotherBlock:anotherBlock},globals.HLToolModel)})},
+args: ["aBlock", "anotherBlock"],
+source: "commitPackageOnSuccess: aBlock onError: anotherBlock\x0a\x09self environment \x0a\x09\x09commitPackage: self packageToCommit\x0a\x09\x09onSuccess: aBlock\x0a\x09\x09onError: anotherBlock",
+messageSends: ["commitPackage:onSuccess:onError:", "environment", "packageToCommit"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "compilationProtocol",
+protocol: 'private',
+fn: function (){
+var self=this;
+var currentProtocol;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$receiver;
+currentProtocol=self._selectedProtocol();
+$1=currentProtocol;
+if(($receiver = $1) == null || $receiver.isNil){
+currentProtocol=self._unclassifiedProtocol();
+$ctx1.sendIdx["unclassifiedProtocol"]=1;
+currentProtocol;
+} else {
+$1;
+};
+$2=self._selectedMethod();
+$ctx1.sendIdx["selectedMethod"]=1;
+if(($receiver = $2) == null || $receiver.isNil){
+$2;
+} else {
+currentProtocol=_st(self._selectedMethod())._protocol();
+currentProtocol;
+};
+$4=_st(currentProtocol).__eq(self._allProtocol());
+if(smalltalk.assert($4)){
+$3=self._unclassifiedProtocol();
+} else {
+$3=currentProtocol;
+};
+return $3;
+}, function($ctx1) {$ctx1.fill(self,"compilationProtocol",{currentProtocol:currentProtocol},globals.HLToolModel)})},
+args: [],
+source: "compilationProtocol\x0a\x09| currentProtocol |\x0a\x09\x0a\x09currentProtocol := self selectedProtocol.\x0a\x09currentProtocol ifNil: [ currentProtocol := self unclassifiedProtocol ].\x0a\x09self selectedMethod ifNotNil: [ currentProtocol := self selectedMethod protocol ].\x0a\x0a\x09^ currentProtocol = self allProtocol\x0a\x09\x09ifTrue: [ self unclassifiedProtocol ]\x0a\x09\x09ifFalse: [ currentProtocol ]",
+messageSends: ["selectedProtocol", "ifNil:", "unclassifiedProtocol", "ifNotNil:", "selectedMethod", "protocol", "ifTrue:ifFalse:", "=", "allProtocol"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "compileClassComment:",
+protocol: 'compiling',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._compileClassComment_for_(aString,self._selectedClass());
+return self}, function($ctx1) {$ctx1.fill(self,"compileClassComment:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+source: "compileClassComment: aString\x0a\x09self environment \x0a\x09\x09compileClassComment: aString \x0a\x09\x09for: self selectedClass",
+messageSends: ["compileClassComment:for:", "environment", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "compileClassDefinition:",
+protocol: 'compiling',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._compileClassDefinition_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"compileClassDefinition:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+source: "compileClassDefinition: aString\x0a\x09self environment compileClassDefinition: aString",
+messageSends: ["compileClassDefinition:", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "compileMethod:",
+protocol: 'compiling',
+fn: function (aString){
+var self=this;
+var method;
+return smalltalk.withContext(function($ctx1) { 
+self._withCompileErrorHandling_((function(){
+return smalltalk.withContext(function($ctx2) {
+method=_st(self._environment())._compileMethod_for_protocol_(aString,self._selectedClass(),self._compilationProtocol());
+method;
+return self._selectedMethod_(method);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"compileMethod:",{aString:aString,method:method},globals.HLToolModel)})},
+args: ["aString"],
+source: "compileMethod: aString\x0a\x09| method |\x0a\x09\x0a\x09self withCompileErrorHandling: [ \x0a\x09\x09method := self environment \x0a\x09\x09\x09compileMethod: aString \x0a\x09\x09\x09for: self selectedClass\x0a\x09\x09\x09protocol: self compilationProtocol.\x0a\x0a\x09\x09self selectedMethod: method ]",
+messageSends: ["withCompileErrorHandling:", "compileMethod:for:protocol:", "environment", "selectedClass", "compilationProtocol", "selectedMethod:"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "copyClassTo:",
+protocol: 'commands actions',
+fn: function (aClassName){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._copyClass_to_(_st(self._selectedClass())._theNonMetaClass(),aClassName);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"copyClassTo:",{aClassName:aClassName},globals.HLToolModel)})},
+args: ["aClassName"],
+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:", "environment", "theNonMetaClass", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "forceSelectedClass:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._selectedClass_(nil);
+$ctx2.sendIdx["selectedClass:"]=1;
+$1=self._selectedClass_(aClass);
+return $1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"forceSelectedClass:",{aClass:aClass},globals.HLToolModel)})},
+args: ["aClass"],
+source: "forceSelectedClass: aClass\x0a\x09self withChangesDo: [\x0a\x09\x09self \x09\x0a\x09\x09\x09selectedClass: nil;\x0a\x09\x09\x09selectedClass: aClass ]",
+messageSends: ["withChangesDo:", "selectedClass:"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "forceSelectedMethod:",
+protocol: 'accessing',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._selectedMethod_(nil);
+$ctx2.sendIdx["selectedMethod:"]=1;
+$1=self._selectedMethod_(aMethod);
+return $1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"forceSelectedMethod:",{aMethod:aMethod},globals.HLToolModel)})},
+args: ["aMethod"],
+source: "forceSelectedMethod: aMethod\x0a\x09self withChangesDo: [\x0a\x09\x09self \x09\x0a\x09\x09\x09selectedMethod: nil;\x0a\x09\x09\x09selectedMethod: aMethod ]",
+messageSends: ["withChangesDo:", "selectedMethod:"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "forceSelectedPackage:",
+protocol: 'accessing',
+fn: function (aPackage){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._selectedPackage_(nil);
+$ctx2.sendIdx["selectedPackage:"]=1;
+$1=self._selectedPackage_(aPackage);
+return $1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"forceSelectedPackage:",{aPackage:aPackage},globals.HLToolModel)})},
+args: ["aPackage"],
+source: "forceSelectedPackage: aPackage\x0a\x09self withChangesDo: [\x0a\x09\x09self \x09\x0a\x09\x09\x09selectedPackage: nil;\x0a\x09\x09\x09selectedPackage: aPackage ]",
+messageSends: ["withChangesDo:", "selectedPackage:"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "forceSelectedProtocol:",
+protocol: 'accessing',
+fn: function (aProtocol){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._selectedProtocol_(nil);
+$ctx2.sendIdx["selectedProtocol:"]=1;
+$1=self._selectedProtocol_(aProtocol);
+return $1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"forceSelectedProtocol:",{aProtocol:aProtocol},globals.HLToolModel)})},
+args: ["aProtocol"],
+source: "forceSelectedProtocol: aProtocol\x0a\x09self withChangesDo: [\x0a\x09\x09self \x09\x0a\x09\x09\x09selectedProtocol: nil;\x0a\x09\x09\x09selectedProtocol: aProtocol ]",
+messageSends: ["withChangesDo:", "selectedProtocol:"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleCompileError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+function $HLCompileErrorRaised(){return globals.HLCompileErrorRaised||(typeof HLCompileErrorRaised=="undefined"?nil:HLCompileErrorRaised)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLCompileErrorRaised())._new();
+_st($1)._error_(anError);
+$2=_st($1)._yourself();
+_st(self._announcer())._announce_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"handleCompileError:",{anError:anError},globals.HLToolModel)})},
+args: ["anError"],
+source: "handleCompileError: anError\x0a\x09self announcer announce: (HLCompileErrorRaised new\x0a\x09\x09error: anError;\x0a\x09\x09yourself)",
+messageSends: ["announce:", "announcer", "error:", "new", "yourself"],
+referencedClasses: ["HLCompileErrorRaised"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleParseError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+var split,line,column,messageToInsert;
+function $HLParseErrorRaised(){return globals.HLParseErrorRaised||(typeof HLParseErrorRaised=="undefined"?nil:HLParseErrorRaised)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$4,$6,$7,$8,$9,$5;
+split=_st(_st(anError)._messageText())._tokenize_(" : ");
+$ctx1.sendIdx["tokenize:"]=1;
+messageToInsert=_st(split)._second();
+$ctx1.sendIdx["second"]=1;
+$1=_st(split)._first();
+$ctx1.sendIdx["first"]=1;
+$3=_st(split)._first();
+$ctx1.sendIdx["first"]=2;
+$2=_st($3)._size();
+split=_st($1)._copyFrom_to_((21),$2);
+split=_st(split)._tokenize_(" column ");
+line=_st(split)._first();
+column=_st(split)._second();
+$4=self._announcer();
+$6=_st($HLParseErrorRaised())._new();
+$7=$6;
+$8=_st(line)._asNumber();
+$ctx1.sendIdx["asNumber"]=1;
+_st($7)._line_($8);
+_st($6)._column_(_st(column)._asNumber());
+_st($6)._message_(messageToInsert);
+_st($6)._error_(anError);
+$9=_st($6)._yourself();
+$5=$9;
+_st($4)._announce_($5);
+return self}, function($ctx1) {$ctx1.fill(self,"handleParseError:",{anError:anError,split:split,line:line,column:column,messageToInsert:messageToInsert},globals.HLToolModel)})},
+args: ["anError"],
+source: "handleParseError: anError\x0a\x09| split line column messageToInsert |\x0a\x09\x0a\x09split := anError messageText tokenize: ' : '.\x0a\x09messageToInsert := split second.\x0a\x0a\x09\x2221 = 'Parse error on line ' size + 1\x22\x0a\x09split := split first copyFrom: 21 to: split first size.\x0a\x09\x0a\x09split := split tokenize: ' column '.\x0a\x09line := split first.\x0a\x09column := split second.\x0a\x09\x0a\x09self announcer announce: (HLParseErrorRaised new\x0a\x09\x09line: line asNumber;\x0a\x09\x09column: column asNumber;\x0a\x09\x09message: messageToInsert;\x0a\x09\x09error: anError;\x0a\x09\x09yourself)",
+messageSends: ["tokenize:", "messageText", "second", "copyFrom:to:", "first", "size", "announce:", "announcer", "line:", "new", "asNumber", "column:", "message:", "error:", "yourself"],
+referencedClasses: ["HLParseErrorRaised"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleUnkownVariableError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+function $HLUnknownVariableErrorRaised(){return globals.HLUnknownVariableErrorRaised||(typeof HLUnknownVariableErrorRaised=="undefined"?nil:HLUnknownVariableErrorRaised)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLUnknownVariableErrorRaised())._new();
+_st($1)._error_(anError);
+$2=_st($1)._yourself();
+_st(self._announcer())._announce_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"handleUnkownVariableError:",{anError:anError},globals.HLToolModel)})},
+args: ["anError"],
+source: "handleUnkownVariableError: anError\x0a\x09self announcer announce: (HLUnknownVariableErrorRaised new\x0a\x09\x09error: anError;\x0a\x09\x09yourself)",
+messageSends: ["announce:", "announcer", "error:", "new", "yourself"],
+referencedClasses: ["HLUnknownVariableErrorRaised"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isToolModel",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isToolModel\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "moveClassToPackage:",
+protocol: 'commands actions',
+fn: function (aPackageName){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._moveClass_toPackage_(_st(self._selectedClass())._theNonMetaClass(),aPackageName);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"moveClassToPackage:",{aPackageName:aPackageName},globals.HLToolModel)})},
+args: ["aPackageName"],
+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:", "environment", "theNonMetaClass", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "moveMethodToClass:",
+protocol: 'commands actions',
+fn: function (aClassName){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._moveMethod_toClass_(self._selectedMethod(),aClassName);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"moveMethodToClass:",{aClassName:aClassName},globals.HLToolModel)})},
+args: ["aClassName"],
+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:", "environment", "selectedMethod"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "moveMethodToProtocol:",
+protocol: 'commands actions',
+fn: function (aProtocol){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._moveMethod_toProtocol_(self._selectedMethod(),aProtocol);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"moveMethodToProtocol:",{aProtocol:aProtocol},globals.HLToolModel)})},
+args: ["aProtocol"],
+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:", "environment", "selectedMethod"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openClassNamed:",
+protocol: 'commands actions',
+fn: function (aString){
+var self=this;
+var class_;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+class_=_st(self._environment())._classNamed_(aString);
+class_;
+self._selectedPackage_(_st(class_)._package());
+return self._selectedClass_(class_);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"openClassNamed:",{aString:aString,class_:class_},globals.HLToolModel)})},
+args: ["aString"],
+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: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "packageToCommit",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self._selectedMethod();
+if(($receiver = $2) == null || $receiver.isNil){
+$1=self._selectedPackage();
+} else {
+var method;
+method=$receiver;
+$1=_st(method)._package();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"packageToCommit",{},globals.HLToolModel)})},
+args: [],
+source: "packageToCommit\x0a\x09\x22Answer the package to commit depending on the context:\x0a\x09- if a Method is selected, answer its package\x0a\x09- else answer the `selectedPackage`\x22\x0a\x09\x0a\x09^ self selectedMethod \x0a\x09\x09ifNil: [ self selectedPackage ]\x0a\x09\x09ifNotNil: [ :method | method package ]",
+messageSends: ["ifNil:ifNotNil:", "selectedMethod", "selectedPackage", "package"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "packages",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._packages();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"packages",{},globals.HLToolModel)})},
+args: [],
+source: "packages\x0a\x09^ self environment packages",
+messageSends: ["packages", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeClass",
+protocol: 'commands actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$5,$4,$3,$2;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+$1=self._manager();
+$5=self._selectedClass();
+$ctx2.sendIdx["selectedClass"]=1;
+$4=_st($5)._theNonMetaClass();
+$ctx2.sendIdx["theNonMetaClass"]=1;
+$3=_st($4)._name();
+$2="Do you REALLY want to remove class ".__comma($3);
+return _st($1)._confirm_ifTrue_($2,(function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._environment())._removeClass_(_st(self._selectedClass())._theNonMetaClass());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"removeClass",{},globals.HLToolModel)})},
+args: [],
+source: "removeClass\x0a\x09self withChangesDo: [\x0a\x09\x09self manager \x0a\x09\x09\x09confirm: 'Do you REALLY want to remove class ', self selectedClass theNonMetaClass name\x0a\x09\x09\x09ifTrue: [ self environment removeClass: self selectedClass theNonMetaClass ] ]",
+messageSends: ["withChangesDo:", "confirm:ifTrue:", "manager", ",", "name", "theNonMetaClass", "selectedClass", "removeClass:", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeMethod",
+protocol: 'commands actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$7,$6,$5,$4,$3,$9,$8,$2;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+$1=self._manager();
+$7=self._selectedMethod();
+$ctx2.sendIdx["selectedMethod"]=1;
+$6=_st($7)._methodClass();
+$5=_st($6)._name();
+$4="Do you REALLY want to remove method ".__comma($5);
+$3=_st($4).__comma(" >> #");
+$ctx2.sendIdx[","]=2;
+$9=self._selectedMethod();
+$ctx2.sendIdx["selectedMethod"]=2;
+$8=_st($9)._selector();
+$2=_st($3).__comma($8);
+$ctx2.sendIdx[","]=1;
+return _st($1)._confirm_ifTrue_($2,(function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._environment())._removeMethod_(self._selectedMethod());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"removeMethod",{},globals.HLToolModel)})},
+args: [],
+source: "removeMethod\x0a\x09self withChangesDo: [\x0a\x09\x09self manager \x0a\x09\x09\x09confirm: '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:", "confirm:ifTrue:", "manager", ",", "name", "methodClass", "selectedMethod", "selector", "removeMethod:", "environment"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeProtocol",
+protocol: 'commands actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+$1=self._manager();
+$3=self._selectedProtocol();
+$ctx2.sendIdx["selectedProtocol"]=1;
+$2="Do you REALLY want to remove protocol ".__comma($3);
+return _st($1)._confirm_ifTrue_($2,(function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._environment())._removeProtocol_from_(self._selectedProtocol(),self._selectedClass());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"removeProtocol",{},globals.HLToolModel)})},
+args: [],
+source: "removeProtocol\x0a\x09self withChangesDo: [\x0a\x09\x09self manager \x0a\x09\x09\x09confirm: '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:", "confirm:ifTrue:", "manager", ",", "selectedProtocol", "removeProtocol:from:", "environment", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renameClassTo:",
+protocol: 'commands actions',
+fn: function (aClassName){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._renameClass_to_(_st(self._selectedClass())._theNonMetaClass(),aClassName);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renameClassTo:",{aClassName:aClassName},globals.HLToolModel)})},
+args: ["aClassName"],
+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:", "environment", "theNonMetaClass", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renameProtocolTo:",
+protocol: 'commands actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._renameProtocol_to_in_(self._selectedProtocol(),aString,self._selectedClass());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renameProtocolTo:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+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:", "environment", "selectedProtocol", "selectedClass"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "save:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $HLSourceCodeSaved(){return globals.HLSourceCodeSaved||(typeof HLSourceCodeSaved=="undefined"?nil:HLSourceCodeSaved)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(self._announcer())._announce_(_st($HLSourceCodeSaved())._new());
+$1=self._shouldCompileClassDefinition_(aString);
+if(smalltalk.assert($1)){
+self._compileClassDefinition_(aString);
+} else {
+self._compileMethod_(aString);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"save:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+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:", "announcer", "new", "ifTrue:ifFalse:", "shouldCompileClassDefinition:", "compileClassDefinition:", "compileMethod:"],
+referencedClasses: ["HLSourceCodeSaved"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "saveSourceCode",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLSaveSourceCode(){return globals.HLSaveSourceCode||(typeof HLSaveSourceCode=="undefined"?nil:HLSaveSourceCode)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLSaveSourceCode())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"saveSourceCode",{},globals.HLToolModel)})},
+args: [],
+source: "saveSourceCode\x0a\x09self announcer announce: HLSaveSourceCode new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLSaveSourceCode"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selectedClass"];
+return $1;
+},
+args: [],
+source: "selectedClass\x0a\x09^ selectedClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedClass:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1,$4,$6,$5,$7,$receiver;
+$3=self._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+$2=_st($3).__eq(aClass);
+$ctx1.sendIdx["="]=1;
+$1=_st($2)._and_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(aClass)._isNil();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+if(smalltalk.assert($1)){
+return self;
+};
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(self["@selectedClass"]).__eq(aClass);
+if(smalltalk.assert($4)){
+self._selectedProtocol_(nil);
+$ctx2.sendIdx["selectedProtocol:"]=1;
+};
+if(($receiver = aClass) == null || $receiver.isNil){
+self["@selectedClass"]=nil;
+self["@selectedClass"];
+} else {
+$6=_st(aClass)._theNonMetaClass();
+$ctx2.sendIdx["theNonMetaClass"]=1;
+$5=_st($6)._package();
+self._selectedPackage_($5);
+$7=self._showInstance();
+if(smalltalk.assert($7)){
+self["@selectedClass"]=_st(aClass)._theNonMetaClass();
+self["@selectedClass"];
+} else {
+self["@selectedClass"]=_st(aClass)._theMetaClass();
+self["@selectedClass"];
+};
+};
+self._selectedProtocol_(nil);
+return _st(self._announcer())._announce_(_st($HLClassSelected())._on_(self._selectedClass()));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"selectedClass:",{aClass:aClass},globals.HLToolModel)})},
+args: ["aClass"],
+source: "selectedClass: aClass\x0a\x09(self selectedClass = aClass and: [ aClass isNil ]) \x0a\x09\x09ifTrue: [ ^ 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 selectedPackage: aClass theNonMetaClass package.\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: ["ifTrue:", "and:", "=", "selectedClass", "isNil", "withChangesDo:", "selectedProtocol:", "ifNil:ifNotNil:", "selectedPackage:", "package", "theNonMetaClass", "ifTrue:ifFalse:", "showInstance", "theMetaClass", "announce:", "announcer", "on:"],
+referencedClasses: ["HLClassSelected"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedMethod",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+if(($receiver = $2) == null || $receiver.isNil){
+$1=$2;
+} else {
+$1=_st(_st(self._selectedClass())._methodDictionary())._at_ifAbsent_(self["@selectedSelector"],(function(){
+return nil;
+}));
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedMethod",{},globals.HLToolModel)})},
+args: [],
+source: "selectedMethod\x0a\x09^ self selectedClass ifNotNil: [ \x0a\x09\x09self selectedClass methodDictionary \x0a\x09\x09\x09at: selectedSelector \x0a\x09\x09\x09ifAbsent: [ nil ] ]",
+messageSends: ["ifNotNil:", "selectedClass", "at:ifAbsent:", "methodDictionary"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedMethod:",
+protocol: 'accessing',
+fn: function (aCompiledMethod){
+var self=this;
+function $HLMethodSelected(){return globals.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=_st(self["@selectedSelector"]).__eq(aCompiledMethod);
+if(smalltalk.assert($1)){
+return self;
+};
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+if(($receiver = aCompiledMethod) == null || $receiver.isNil){
+self["@selectedSelector"]=nil;
+self["@selectedSelector"];
+} else {
+self["@selectedClass"]=_st(aCompiledMethod)._methodClass();
+self["@selectedClass"];
+self["@selectedPackage"]=_st(_st(self["@selectedClass"])._theNonMetaClass())._package();
+self["@selectedPackage"];
+self["@selectedSelector"]=_st(aCompiledMethod)._selector();
+self["@selectedSelector"];
+};
+return _st(self._announcer())._announce_(_st($HLMethodSelected())._on_(aCompiledMethod));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"selectedMethod:",{aCompiledMethod:aCompiledMethod},globals.HLToolModel)})},
+args: ["aCompiledMethod"],
+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\x09selectedClass := aCompiledMethod methodClass.\x0a\x09\x09\x09\x09selectedPackage := selectedClass theNonMetaClass package.\x0a\x09\x09\x09\x09selectedSelector := aCompiledMethod selector ].\x0a\x0a\x09\x09self announcer announce: (HLMethodSelected on: aCompiledMethod) ]",
+messageSends: ["ifTrue:", "=", "withChangesDo:", "ifNil:ifNotNil:", "methodClass", "package", "theNonMetaClass", "selector", "announce:", "announcer", "on:"],
+referencedClasses: ["HLMethodSelected"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedPackage",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selectedPackage"];
+return $1;
+},
+args: [],
+source: "selectedPackage\x0a\x09^ selectedPackage",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedPackage:",
+protocol: 'accessing',
+fn: function (aPackage){
+var self=this;
+function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@selectedPackage"]).__eq(aPackage);
+if(smalltalk.assert($1)){
+return self;
+};
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@selectedPackage"]=aPackage;
+self["@selectedPackage"];
+self._selectedClass_(nil);
+return _st(self._announcer())._announce_(_st($HLPackageSelected())._on_(aPackage));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"selectedPackage:",{aPackage:aPackage},globals.HLToolModel)})},
+args: ["aPackage"],
+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:", "announcer", "on:"],
+referencedClasses: ["HLPackageSelected"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedProtocol",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selectedProtocol"];
+return $1;
+},
+args: [],
+source: "selectedProtocol\x0a\x09^ selectedProtocol",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedProtocol:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+function $HLProtocolSelected(){return globals.HLProtocolSelected||(typeof HLProtocolSelected=="undefined"?nil:HLProtocolSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@selectedProtocol"]).__eq(aString);
+if(smalltalk.assert($1)){
+return self;
+};
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@selectedProtocol"]=aString;
+self["@selectedProtocol"];
+self._selectedMethod_(nil);
+return _st(self._announcer())._announce_(_st($HLProtocolSelected())._on_(aString));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"selectedProtocol:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+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:", "announcer", "on:"],
+referencedClasses: ["HLProtocolSelected"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "shouldCompileClassDefinition:",
+protocol: 'testing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._selectedClass())._isNil())._or_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(aString)._match_("^\x5cs*[A-Z]");
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"shouldCompileClassDefinition:",{aString:aString},globals.HLToolModel)})},
+args: ["aString"],
+source: "shouldCompileClassDefinition: aString\x0a\x09^ self selectedClass isNil or: [\x0a\x09\x09aString match: '^\x5cs*[A-Z]' ]",
+messageSends: ["or:", "isNil", "selectedClass", "match:"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unclassifiedProtocol",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return "as yet unclassified";
+},
+args: [],
+source: "unclassifiedProtocol\x0a\x09^ 'as yet unclassified'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "withCompileErrorHandling:",
+protocol: 'error handling',
+fn: function (aBlock){
+var self=this;
+function $ParseError(){return globals.ParseError||(typeof ParseError=="undefined"?nil:ParseError)}
+function $UnknownVariableError(){return globals.UnknownVariableError||(typeof UnknownVariableError=="undefined"?nil:UnknownVariableError)}
+function $CompilerError(){return globals.CompilerError||(typeof CompilerError=="undefined"?nil:CompilerError)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._environment();
+$ctx1.sendIdx["environment"]=1;
+_st($1)._evaluate_on_do_((function(){
+return smalltalk.withContext(function($ctx2) {
+$2=self._environment();
+$ctx2.sendIdx["environment"]=2;
+return _st($2)._evaluate_on_do_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._environment())._evaluate_on_do_(aBlock,$ParseError(),(function(ex){
+return smalltalk.withContext(function($ctx4) {
+return self._handleParseError_(ex);
+}, function($ctx4) {$ctx4.fillBlock({ex:ex},$ctx3,3)})}));
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}),$UnknownVariableError(),(function(ex){
+return smalltalk.withContext(function($ctx3) {
+return self._handleUnkownVariableError_(ex);
+}, function($ctx3) {$ctx3.fillBlock({ex:ex},$ctx2,4)})}));
+$ctx2.sendIdx["evaluate:on:do:"]=2;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}),$CompilerError(),(function(ex){
+return smalltalk.withContext(function($ctx2) {
+return self._handleCompileError_(ex);
+}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,5)})}));
+$ctx1.sendIdx["evaluate:on:do:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"withCompileErrorHandling:",{aBlock:aBlock},globals.HLToolModel)})},
+args: ["aBlock"],
+source: "withCompileErrorHandling: aBlock\x0a\x09self environment\x0a\x09\x09evaluate: [\x0a\x09\x09\x09self environment \x0a\x09\x09\x09evaluate: [\x0a\x09\x09\x09\x09self environment \x0a\x09\x09\x09\x09\x09evaluate: aBlock\x0a\x09\x09\x09\x09\x09on: ParseError\x0a\x09\x09\x09\x09\x09do: [ :ex | self handleParseError: ex ] ]\x0a\x09\x09\x09on: UnknownVariableError\x0a\x09\x09\x09do: [ :ex | self handleUnkownVariableError: ex ] ]\x0a\x09\x09on: CompilerError\x0a\x09\x09do: [ :ex | self handleCompileError: ex ]",
+messageSends: ["evaluate:on:do:", "environment", "handleParseError:", "handleUnkownVariableError:", "handleCompileError:"],
+referencedClasses: ["ParseError", "UnknownVariableError", "CompilerError"]
+}),
+globals.HLToolModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "withHelperLabelled:do:",
+protocol: 'private',
+fn: function (aString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$2,$5;
+$1="#helper"._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._remove();
+$ctx1.sendIdx["remove"]=1;
+$2=(function(html){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._div();
+_st($3)._id_("helper");
+$4=_st($3)._with_(aString);
+return $4;
+}, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)})});
+$5="body"._asJQuery();
+$ctx1.sendIdx["asJQuery"]=2;
+_st($2)._appendToJQuery_($5);
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+_st(aBlock)._value();
+return _st("#helper"._asJQuery())._remove();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}))._valueWithTimeout_((10));
+return self}, function($ctx1) {$ctx1.fill(self,"withHelperLabelled:do:",{aString:aString,aBlock:aBlock},globals.HLToolModel)})},
+args: ["aString", "aBlock"],
+source: "withHelperLabelled: aString do: aBlock\x0a\x09\x22TODO: doesn't belong here\x22\x0a\x0a\x09'#helper' asJQuery remove.\x0a\x0a\x09[ :html |\x0a\x09\x09html div \x0a\x09\x09\x09id: 'helper';\x0a\x09\x09\x09with: aString ] appendToJQuery: 'body' asJQuery.\x0a\x09\x0a\x09[\x0a\x09\x09aBlock value.\x0a\x09\x09'#helper' asJQuery remove\x0a\x09] \x0a\x09\x09valueWithTimeout: 10",
+messageSends: ["remove", "asJQuery", "appendToJQuery:", "id:", "div", "with:", "valueWithTimeout:", "value"],
+referencedClasses: []
+}),
+globals.HLToolModel);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'actions',
+fn: function (anEnvironment){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._environment_(anEnvironment);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anEnvironment:anEnvironment},globals.HLToolModel.klass)})},
+args: ["anEnvironment"],
+source: "on: anEnvironment\x0a\x0a\x09^ self new\x0a    \x09environment: anEnvironment;\x0a        yourself",
+messageSends: ["environment:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLToolModel.klass);
+
+
+smalltalk.addClass('HLProgressHandler', globals.Object, [], 'Helios-Core');
+globals.HLProgressHandler.comment="I am a specific progress handler for Helios, displaying progresses in a modal window.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "do:on:displaying:",
+protocol: 'progress handling',
+fn: function (aBlock,aCollection,aString){
+var self=this;
+function $HLProgressWidget(){return globals.HLProgressWidget||(typeof HLProgressWidget=="undefined"?nil:HLProgressWidget)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLProgressWidget())._default())._do_on_displaying_(aBlock,aCollection,aString);
+return self}, function($ctx1) {$ctx1.fill(self,"do:on:displaying:",{aBlock:aBlock,aCollection:aCollection,aString:aString},globals.HLProgressHandler)})},
+args: ["aBlock", "aCollection", "aString"],
+source: "do: aBlock on: aCollection displaying: aString\x0a\x09HLProgressWidget default\x0a\x09\x09do: aBlock \x0a\x09\x09on: aCollection \x0a\x09\x09displaying: aString",
+messageSends: ["do:on:displaying:", "default"],
+referencedClasses: ["HLProgressWidget"]
+}),
+globals.HLProgressHandler);
+
+
+
+smalltalk.addClass('HLWidget', globals.Widget, ['wrapper'], 'Helios-Core');
+globals.HLWidget.comment="I am the abstract superclass of all Helios widgets.\x0a\x0aI provide common methods, additional behavior to widgets useful for Helios, like dialog creation, command execution and tab creation.\x0a\x0a## API\x0a\x0a1. Rendering\x0a\x0a    Instead of overriding `#renderOn:` as with other Widget subclasses, my subclasses should override `#renderContentOn:`.\x0a\x0a2. Refreshing\x0a\x0a    To re-render a widget, use `#refresh`.\x0a\x0a3. Key bindings registration and tabs\x0a\x0a    When displayed as a tab, the widget has a chance to register keybindings with the `#registerBindingsOn:` hook method.\x0a    \x0a4. Unregistration\x0a\x0a    When a widget has subscribed to announcements or other actions that need to be cleared when closing the tab, the hook method `#unregister` will be called by helios.\x0a\x0a5. Tabs\x0a\x0a   To enable a widget class to be open as a tab, override the class-side `#canBeOpenAsTab` method to answer `true`. `#tabClass` and `#tabPriority` can be overridden too to respectively change the css class of the tab and the order of tabs in the main menu.\x0a\x0a6. Command execution\x0a\x0a    An helios command (instance of `HLCommand` or one of its subclass) can be executed with `#execute:`.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "bindKeyDown:keyUp:",
+protocol: 'keybindings',
+fn: function (keyDownBlock,keyUpBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._wrapper())._asJQuery();
+_st($1)._keydown_(keyDownBlock);
+$2=_st($1)._keyup_(keyUpBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"bindKeyDown:keyUp:",{keyDownBlock:keyDownBlock,keyUpBlock:keyUpBlock},globals.HLWidget)})},
+args: ["keyDownBlock", "keyUpBlock"],
+source: "bindKeyDown: keyDownBlock keyUp: keyUpBlock\x0a\x09self wrapper asJQuery\x0a\x09\x09keydown: keyDownBlock;\x0a\x09\x09keyup: keyUpBlock",
+messageSends: ["keydown:", "asJQuery", "wrapper", "keyup:"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canHaveFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "canHaveFocus\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm:ifTrue:",
+protocol: 'actions',
+fn: function (aString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._confirm_ifTrue_(aString,aBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"confirm:ifTrue:",{aString:aString,aBlock:aBlock},globals.HLWidget)})},
+args: ["aString", "aBlock"],
+source: "confirm: aString ifTrue: aBlock\x0a\x09self manager confirm: aString ifTrue: aBlock",
+messageSends: ["confirm:ifTrue:", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm:ifTrue:ifFalse:",
+protocol: 'actions',
+fn: function (aString,aBlock,anotherBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._confirm_ifTrue_ifFalse_(aString,aBlock,anotherBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"confirm:ifTrue:ifFalse:",{aString:aString,aBlock:aBlock,anotherBlock:anotherBlock},globals.HLWidget)})},
+args: ["aString", "aBlock", "anotherBlock"],
+source: "confirm: aString ifTrue: aBlock ifFalse: anotherBlock\x0a\x09self manager \x0a\x09\x09confirm: aString \x0a\x09\x09ifTrue: aBlock\x0a\x09\x09ifFalse: anotherBlock",
+messageSends: ["confirm:ifTrue:ifFalse:", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "hl_widget";
+},
+args: [],
+source: "cssClass\x0a\x09^ 'hl_widget'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultTabLabel",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._tabLabel();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultTabLabel",{},globals.HLWidget)})},
+args: [],
+source: "defaultTabLabel\x0a\x09^ self class tabLabel",
+messageSends: ["tabLabel", "class"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute:",
+protocol: 'actions',
+fn: function (aCommand){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(_st($HLManager())._current())._keyBinder();
+_st($1)._activate();
+$2=_st($1)._applyBinding_(_st(aCommand)._asBinding());
+return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aCommand:aCommand},globals.HLWidget)})},
+args: ["aCommand"],
+source: "execute: aCommand\x0a\x09HLManager current keyBinder\x0a\x09\x09activate;\x0a\x09\x09applyBinding: aCommand asBinding",
+messageSends: ["activate", "keyBinder", "current", "applyBinding:", "asBinding"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inform:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._inform_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"inform:",{aString:aString},globals.HLWidget)})},
+args: ["aString"],
+source: "inform: aString\x0a\x09self manager inform: aString",
+messageSends: ["inform:", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "manager",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLManager())._current();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"manager",{},globals.HLWidget)})},
+args: [],
+source: "manager\x0a\x09^ HLManager current",
+messageSends: ["current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openAsTab",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLTabWidget(){return globals.HLTabWidget||(typeof HLTabWidget=="undefined"?nil:HLTabWidget)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLTabWidget())._on_labelled_(self,self._defaultTabLabel()))._add();
+return self}, function($ctx1) {$ctx1.fill(self,"openAsTab",{},globals.HLWidget)})},
+args: [],
+source: "openAsTab\x0a\x09(HLTabWidget on: self labelled: self defaultTabLabel)\x0a\x09\x09add",
+messageSends: ["add", "on:labelled:", "defaultTabLabel"],
+referencedClasses: ["HLTabWidget"]
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refresh",
+protocol: 'updating',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$receiver;
+$1=self._wrapper();
+$ctx1.sendIdx["wrapper"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+$3=self._wrapper();
+$ctx1.sendIdx["wrapper"]=2;
+$2=_st($3)._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($2)._empty();
+_st((function(html){
+return smalltalk.withContext(function($ctx2) {
+return self._renderContentOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,2)})}))._appendToJQuery_(_st(self._wrapper())._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},globals.HLWidget)})},
+args: [],
+source: "refresh\x0a\x09self wrapper ifNil: [ ^ self ].\x0a    \x0a\x09self wrapper asJQuery empty.\x0a    [ :html | self renderContentOn: html ] appendToJQuery: self wrapper asJQuery",
+messageSends: ["ifNil:", "wrapper", "empty", "asJQuery", "appendToJQuery:", "renderContentOn:"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerBindings",
+protocol: 'keybindings',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._registerBindingsOn_(_st(_st(self._manager())._keyBinder())._bindings());
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindings",{},globals.HLWidget)})},
+args: [],
+source: "registerBindings\x0a\x09self registerBindingsOn: self manager keyBinder bindings",
+messageSends: ["registerBindingsOn:", "bindings", "keyBinder", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerBindingsOn:",
+protocol: 'keybindings',
+fn: function (aBindingGroup){
+var self=this;
+return self},
+args: ["aBindingGroup"],
+source: "registerBindingsOn: aBindingGroup",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeTab",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._removeTabForWidget_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"removeTab",{},globals.HLWidget)})},
+args: [],
+source: "removeTab\x0a\x09self manager removeTabForWidget: self",
+messageSends: ["removeTabForWidget:", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return self},
+args: ["html"],
+source: "renderContentOn: html",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_(self._cssClass());
+$2=_st($1)._yourself();
+self["@wrapper"]=$2;
+_st((function(renderer){
+return smalltalk.withContext(function($ctx2) {
+return self._renderContentOn_(renderer);
+}, function($ctx2) {$ctx2.fillBlock({renderer:renderer},$ctx1,1)})}))._appendToJQuery_(_st(self["@wrapper"])._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLWidget)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09wrapper := html div\x0a\x09\x09class: self cssClass;\x0a\x09\x09yourself.\x0a    [ :renderer | self renderContentOn: renderer ] appendToJQuery: wrapper asJQuery",
+messageSends: ["class:", "div", "cssClass", "yourself", "appendToJQuery:", "renderContentOn:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "request:do:",
+protocol: 'actions',
+fn: function (aString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._request_do_(aString,aBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"request:do:",{aString:aString,aBlock:aBlock},globals.HLWidget)})},
+args: ["aString", "aBlock"],
+source: "request: aString do: aBlock\x0a\x09self manager request: aString do: aBlock",
+messageSends: ["request:do:", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "request:value:do:",
+protocol: 'actions',
+fn: function (aString,valueString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._request_value_do_(aString,valueString,aBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"request:value:do:",{aString:aString,valueString:valueString,aBlock:aBlock},globals.HLWidget)})},
+args: ["aString", "valueString", "aBlock"],
+source: "request: aString value: valueString do: aBlock\x0a\x09self manager \x0a\x09\x09request: aString \x0a\x09\x09value: valueString\x0a\x09\x09do: aBlock",
+messageSends: ["request:value:do:", "manager"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setTabLabel:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+function $HLTabLabelChanged(){return globals.HLTabLabelChanged||(typeof HLTabLabelChanged=="undefined"?nil:HLTabLabelChanged)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLTabLabelChanged())._new();
+_st($1)._widget_(self);
+_st($1)._label_(aString);
+$2=_st($1)._yourself();
+_st(_st(self._manager())._announcer())._announce_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"setTabLabel:",{aString:aString},globals.HLWidget)})},
+args: ["aString"],
+source: "setTabLabel: aString\x0a\x09self manager announcer announce: (HLTabLabelChanged new\x0a\x09\x09widget: self;\x0a\x09\x09label: aString;\x0a\x09\x09yourself)",
+messageSends: ["announce:", "announcer", "manager", "widget:", "new", "label:", "yourself"],
+referencedClasses: ["HLTabLabelChanged"]
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._tabClass();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabClass",{},globals.HLWidget)})},
+args: [],
+source: "tabClass\x0a\x09^ self class tabClass",
+messageSends: ["tabClass", "class"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unbindKeyDownKeyUp",
+protocol: 'keybindings',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._wrapper())._asJQuery();
+_st($1)._unbind_("keydown");
+$ctx1.sendIdx["unbind:"]=1;
+$2=_st($1)._unbind_("keyup");
+return self}, function($ctx1) {$ctx1.fill(self,"unbindKeyDownKeyUp",{},globals.HLWidget)})},
+args: [],
+source: "unbindKeyDownKeyUp\x0a\x09self wrapper asJQuery\x0a\x09\x09unbind: 'keydown';\x0a\x09\x09unbind: 'keyup'",
+messageSends: ["unbind:", "asJQuery", "wrapper"],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "unregister\x0a\x09\x22This method is called whenever the receiver is closed (as a tab).\x0a\x09Widgets subscribing to announcements should unregister there\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "wrapper",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@wrapper"];
+return $1;
+},
+args: [],
+source: "wrapper\x0a\x09^ wrapper",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openAsTab",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var instance;
+function $HLTabWidget(){return globals.HLTabWidget||(typeof HLTabWidget=="undefined"?nil:HLTabWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+instance=self._new();
+_st(_st($HLTabWidget())._on_labelled_(instance,_st(instance)._defaultTabLabel()))._add();
+$1=instance;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"openAsTab",{instance:instance},globals.HLWidget.klass)})},
+args: [],
+source: "openAsTab\x0a\x09| instance |\x0a\x09\x0a\x09instance := self new.\x0a\x09(HLTabWidget \x0a\x09\x09on: instance \x0a\x09\x09labelled: instance defaultTabLabel) add.\x0a\x09^ instance",
+messageSends: ["new", "add", "on:labelled:", "defaultTabLabel"],
+referencedClasses: ["HLTabWidget"]
+}),
+globals.HLWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "";
+},
+args: [],
+source: "tabClass\x0a\x09^ ''",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Tab";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'Tab'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabPriority",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (500);
+},
+args: [],
+source: "tabPriority\x0a\x09^ 500",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWidget.klass);
+
+
+smalltalk.addClass('HLFocusableWidget', globals.HLWidget, [], 'Helios-Core');
+globals.HLFocusableWidget.comment="I am a widget that can be focused.\x0a\x0a## API \x0a\x0aInstead of overriding `#renderOn:` as with other `Widget` subclasses, my subclasses should override `#renderContentOn:`.\x0a\x0aTo bring the focus to the widget, use the `#focus` method.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "blur",
+protocol: 'events',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._wrapper())._asJQuery())._blur();
+return self}, function($ctx1) {$ctx1.fill(self,"blur",{},globals.HLFocusableWidget)})},
+args: [],
+source: "blur\x0a\x09self wrapper asJQuery blur",
+messageSends: ["blur", "asJQuery", "wrapper"],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canHaveFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canHaveFocus\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'events',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._wrapper())._asJQuery())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLFocusableWidget)})},
+args: [],
+source: "focus\x0a\x09self wrapper asJQuery focus",
+messageSends: ["focus", "asJQuery", "wrapper"],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focusClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "focused";
+},
+args: [],
+source: "focusClass\x0a\x09^ 'focused'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hasFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1;
+$3=self._wrapper();
+$ctx1.sendIdx["wrapper"]=1;
+$2=_st($3)._notNil();
+$1=_st($2)._and_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(self._wrapper())._asJQuery())._hasClass_(self._focusClass());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"hasFocus",{},globals.HLFocusableWidget)})},
+args: [],
+source: "hasFocus\x0a\x09^ self wrapper notNil and: [ self wrapper asJQuery hasClass: self focusClass ]",
+messageSends: ["and:", "notNil", "wrapper", "hasClass:", "asJQuery", "focusClass"],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return self},
+args: ["html"],
+source: "renderContentOn: html",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$5,$4,$6,$7;
+$1=_st(html)._div();
+_st($1)._class_(self._cssClass());
+$2=_st($1)._yourself();
+self["@wrapper"]=$2;
+_st(self["@wrapper"])._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._renderContentOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$3=self["@wrapper"];
+_st($3)._at_put_("tabindex","0");
+_st($3)._onBlur_((function(){
+return smalltalk.withContext(function($ctx2) {
+$5=self._wrapper();
+$ctx2.sendIdx["wrapper"]=1;
+$4=_st($5)._asJQuery();
+$ctx2.sendIdx["asJQuery"]=1;
+$6=self._focusClass();
+$ctx2.sendIdx["focusClass"]=1;
+return _st($4)._removeClass_($6);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$7=_st($3)._onFocus_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(self._wrapper())._asJQuery())._addClass_(self._focusClass());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLFocusableWidget)})},
+args: ["html"],
+source: "renderOn: html\x0a    wrapper := html div \x0a    \x09class: self cssClass;\x0a\x09\x09yourself.\x0a\x09\x09\x0a       wrapper with: [ self renderContentOn: html ].\x0a\x09\x0a\x09wrapper\x0a\x09\x09at: 'tabindex' put: '0';\x0a\x09\x09onBlur: [ self wrapper asJQuery removeClass: self focusClass ];\x0a        onFocus: [ self wrapper asJQuery addClass: self focusClass ]",
+messageSends: ["class:", "div", "cssClass", "yourself", "with:", "renderContentOn:", "at:put:", "onBlur:", "removeClass:", "asJQuery", "wrapper", "focusClass", "onFocus:", "addClass:"],
+referencedClasses: []
+}),
+globals.HLFocusableWidget);
+
+
+
+smalltalk.addClass('HLListWidget', globals.HLFocusableWidget, ['items', 'selectedItem'], 'Helios-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateFirstListItem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._activateListItem_(_st(_st(_st(self["@wrapper"])._asJQuery())._find_("li.inactive"))._eq_((0)));
+return self}, function($ctx1) {$ctx1.fill(self,"activateFirstListItem",{},globals.HLListWidget)})},
+args: [],
+source: "activateFirstListItem\x0a\x09self activateListItem: ((wrapper asJQuery find: 'li.inactive') eq: 0)",
+messageSends: ["activateListItem:", "eq:", "find:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateItem:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._activateListItem_(self._findListItemFor_(anObject));
+return self}, function($ctx1) {$ctx1.fill(self,"activateItem:",{anObject:anObject},globals.HLListWidget)})},
+args: ["anObject"],
+source: "activateItem: anObject\x0a\x09self activateListItem: (self findListItemFor: anObject)",
+messageSends: ["activateListItem:", "findListItemFor:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateListItem:",
+protocol: 'actions',
+fn: function (aListItem){
+var self=this;
+var item;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+$1=_st(aListItem)._get_((0));
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+_st(_st(_st(aListItem)._parent())._children())._removeClass_("active");
+_st(aListItem)._addClass_("active");
+self._ensureVisible_(aListItem);
+item=_st(aListItem)._data_("item");
+$2=_st(self._selectedItem()).__eq_eq(item);
+if(! smalltalk.assert($2)){
+self._selectItem_(item);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"activateListItem:",{aListItem:aListItem,item:item},globals.HLListWidget)})},
+args: ["aListItem"],
+source: "activateListItem: aListItem\x0a\x09| item |\x0a\x09\x0a\x09(aListItem get: 0) ifNil: [ ^ self ].\x0a\x09aListItem parent children removeClass: 'active'.\x0a\x09aListItem addClass: 'active'.\x0a    \x0a\x09self ensureVisible: aListItem.\x0a    \x0a   \x22Activate the corresponding item\x22\x0a   item := aListItem data: 'item'.\x0a   self selectedItem == item ifFalse: [\x0a\x09   self selectItem: item ]",
+messageSends: ["ifNil:", "get:", "removeClass:", "children", "parent", "addClass:", "ensureVisible:", "data:", "ifFalse:", "==", "selectedItem", "selectItem:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateNextListItem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $4,$3,$2,$1;
+$4=self._wrapper();
+$ctx1.sendIdx["wrapper"]=1;
+$3=_st($4)._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+$2=_st($3)._find_("li.active");
+$ctx1.sendIdx["find:"]=1;
+$1=_st($2)._next();
+self._activateListItem_($1);
+_st(_st(_st(_st(self._wrapper())._asJQuery())._find_(" .active"))._get())._ifEmpty_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._activateFirstListItem();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"activateNextListItem",{},globals.HLListWidget)})},
+args: [],
+source: "activateNextListItem\x0a\x09self activateListItem: (self wrapper asJQuery find: 'li.active') next.\x0a\x09\x0a\x09\x22select the first item if none is selected\x22\x0a\x09(self wrapper asJQuery find: ' .active') get ifEmpty: [\x0a\x09\x09self activateFirstListItem ]",
+messageSends: ["activateListItem:", "next", "find:", "asJQuery", "wrapper", "ifEmpty:", "get", "activateFirstListItem"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activatePreviousListItem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._activateListItem_(_st(_st(_st(self._wrapper())._asJQuery())._find_("li.active"))._prev());
+return self}, function($ctx1) {$ctx1.fill(self,"activatePreviousListItem",{},globals.HLListWidget)})},
+args: [],
+source: "activatePreviousListItem\x0a\x09self activateListItem: (self wrapper asJQuery find: 'li.active') prev",
+messageSends: ["activateListItem:", "prev", "find:", "asJQuery", "wrapper"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClassForItem:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+return "";
+},
+args: ["anObject"],
+source: "cssClassForItem: anObject\x0a\x09^ ''",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultItems",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+var $1;
+$1=[];
+return $1;
+},
+args: [],
+source: "defaultItems\x0a\x09^ #()",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "ensureVisible:",
+protocol: 'actions',
+fn: function (aListItem){
+var self=this;
+var parent,position;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$4,$3,$2,$5,$9,$8,$11,$10,$7,$6,$15,$14,$16,$13,$17,$12,$18,$22,$23,$21,$20,$19,$receiver;
+$1=_st(aListItem)._get_((0));
+$ctx1.sendIdx["get:"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+position=self._positionOf_(aListItem);
+parent=_st(aListItem)._parent();
+$4=_st(aListItem)._position();
+$ctx1.sendIdx["position"]=1;
+$3=_st($4)._top();
+$ctx1.sendIdx["top"]=1;
+$2=_st($3).__lt((0));
+if(smalltalk.assert($2)){
+$5=_st(parent)._get_((0));
+$ctx1.sendIdx["get:"]=2;
+$9=_st(parent)._get_((0));
+$ctx1.sendIdx["get:"]=3;
+$8=_st($9)._scrollTop();
+$ctx1.sendIdx["scrollTop"]=1;
+$11=_st(aListItem)._position();
+$ctx1.sendIdx["position"]=2;
+$10=_st($11)._top();
+$ctx1.sendIdx["top"]=2;
+$7=_st($8).__plus($10);
+$ctx1.sendIdx["+"]=1;
+$6=_st($7).__minus((10));
+$ctx1.sendIdx["-"]=1;
+_st($5)._scrollTop_($6);
+$ctx1.sendIdx["scrollTop:"]=1;
+};
+$15=_st(aListItem)._position();
+$ctx1.sendIdx["position"]=3;
+$14=_st($15)._top();
+$ctx1.sendIdx["top"]=3;
+$16=_st(aListItem)._height();
+$ctx1.sendIdx["height"]=1;
+$13=_st($14).__plus($16);
+$ctx1.sendIdx["+"]=2;
+$17=_st(parent)._height();
+$ctx1.sendIdx["height"]=2;
+$12=_st($13).__gt($17);
+if(smalltalk.assert($12)){
+$18=_st(parent)._get_((0));
+$ctx1.sendIdx["get:"]=4;
+$22=_st(_st(parent)._get_((0)))._scrollTop();
+$23=_st(aListItem)._height();
+$ctx1.sendIdx["height"]=3;
+$21=_st($22).__plus($23);
+$20=_st($21).__minus(_st(_st(parent)._height()).__minus(_st(_st(aListItem)._position())._top()));
+$ctx1.sendIdx["-"]=2;
+$19=_st($20).__plus((10));
+$ctx1.sendIdx["+"]=3;
+_st($18)._scrollTop_($19);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"ensureVisible:",{aListItem:aListItem,parent:parent,position:position},globals.HLListWidget)})},
+args: ["aListItem"],
+source: "ensureVisible: aListItem\x09\x0a\x09\x22Move the scrollbar to show the active element\x22\x0a\x09\x0a\x09| parent position |\x0a\x09(aListItem get: 0) ifNil: [ ^ self ].\x0a\x09position := self positionOf: aListItem.\x0a\x09parent := aListItem parent.\x0a\x09\x0a    aListItem position top < 0 ifTrue: [\x0a\x09\x09(parent get: 0) scrollTop: ((parent get: 0) scrollTop + aListItem position top - 10) ].\x0a    aListItem position top + aListItem height > parent height ifTrue: [ \x0a\x09\x09(parent get: 0) scrollTop: ((parent get: 0) scrollTop + aListItem height - (parent height - aListItem position top)) +10 ]",
+messageSends: ["ifNil:", "get:", "positionOf:", "parent", "ifTrue:", "<", "top", "position", "scrollTop:", "-", "+", "scrollTop", ">", "height"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "findListItemFor:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $4,$3,$2,$1;
+$4=_st(self["@wrapper"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+$3=_st($4)._find_("li");
+$2=_st($3)._filter_(_st((function(thisArg,otherArg){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(_st(thisArg)._asJQuery())._data_("item")).__eq(anObject);
+}, function($ctx2) {$ctx2.fillBlock({thisArg:thisArg,otherArg:otherArg},$ctx1,1)})}))._currySelf());
+$1=_st($2)._eq_((0));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"findListItemFor:",{anObject:anObject},globals.HLListWidget)})},
+args: ["anObject"],
+source: "findListItemFor: anObject\x0a\x09^ (((wrapper asJQuery find: 'li') \x0a\x09\x09filter: [ :thisArg :otherArg | (thisArg asJQuery data: 'item') = anObject ] currySelf) eq: 0)",
+messageSends: ["eq:", "filter:", "find:", "asJQuery", "currySelf", "=", "data:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+($ctx1.supercall = true, globals.HLListWidget.superclass.fn.prototype._focus.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st(self._items())._isEmpty();
+if(! smalltalk.assert($1)){
+$2=self._selectedItem();
+if(($receiver = $2) == null || $receiver.isNil){
+self._activateFirstListItem();
+} else {
+$2;
+};
+};
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLListWidget)})},
+args: [],
+source: "focus\x0a\x09super focus.\x0a    self items isEmpty ifFalse: [ \x0a\x09\x09self selectedItem ifNil: [ self activateFirstListItem ] ]",
+messageSends: ["focus", "ifFalse:", "isEmpty", "items", "ifNil:", "selectedItem", "activateFirstListItem"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "items",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@items"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@items"]=self._defaultItems();
+$1=self["@items"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"items",{},globals.HLListWidget)})},
+args: [],
+source: "items\x0a\x09^ items ifNil: [ items := self defaultItems ]",
+messageSends: ["ifNil:", "defaultItems"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "items:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@items"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "items: aCollection\x0a\x09items := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "listCssClassForItem:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=_st(self._selectedItem()).__eq(anObject);
+if(smalltalk.assert($2)){
+$1="active";
+} else {
+$1="inactive";
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"listCssClassForItem:",{anObject:anObject},globals.HLListWidget)})},
+args: ["anObject"],
+source: "listCssClassForItem: anObject\x0a\x09^ self selectedItem = anObject\x0a\x09\x09ifTrue: [ 'active' ]\x0a\x09\x09ifFalse: [ 'inactive' ]",
+messageSends: ["ifTrue:ifFalse:", "=", "selectedItem"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "positionOf:",
+protocol: 'accessing',
+fn: function (aListItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+
+    	return aListItem.parent().children().get().indexOf(aListItem.get(0)) + 1
+	;
+return self}, function($ctx1) {$ctx1.fill(self,"positionOf:",{aListItem:aListItem},globals.HLListWidget)})},
+args: ["aListItem"],
+source: "positionOf: aListItem\x0a\x09<\x0a    \x09return aListItem.parent().children().get().indexOf(aListItem.get(0)) + 1\x0a\x09>",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reactivateListItem:",
+protocol: 'actions',
+fn: function (aListItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._activateListItem_(aListItem);
+self._reselectItem_(self._selectedItem());
+return self}, function($ctx1) {$ctx1.fill(self,"reactivateListItem:",{aListItem:aListItem},globals.HLListWidget)})},
+args: ["aListItem"],
+source: "reactivateListItem: aListItem\x0a\x09self activateListItem: aListItem.\x0a\x09self reselectItem: self selectedItem",
+messageSends: ["activateListItem:", "reselectItem:", "selectedItem"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refresh",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+($ctx1.supercall = true, globals.HLListWidget.superclass.fn.prototype._refresh.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=self._selectedItem();
+$ctx1.sendIdx["selectedItem"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+self._ensureVisible_(self._findListItemFor_(self._selectedItem()));
+};
+return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},globals.HLListWidget)})},
+args: [],
+source: "refresh\x0a\x09super refresh.\x0a\x09self selectedItem ifNotNil: [self ensureVisible: (self findListItemFor: self selectedItem)].",
+messageSends: ["refresh", "ifNotNil:", "selectedItem", "ensureVisible:", "findListItemFor:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return self},
+args: ["html"],
+source: "renderButtonsOn: html",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4;
+$1=_st(html)._ul();
+_st($1)._class_("nav nav-pills nav-stacked");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._renderListOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+$3=_st(html)._div();
+_st($3)._class_("pane_actions form-actions");
+$4=_st($3)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._renderButtonsOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+self._setupKeyBindings();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLListWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html ul \x0a    \x09class: 'nav nav-pills nav-stacked';\x0a        with: [ self renderListOn: html ].\x0a    html div class: 'pane_actions form-actions'; with: [\x0a      \x09self renderButtonsOn: html ].\x0a        \x0a   self setupKeyBindings",
+messageSends: ["class:", "ul", "with:", "renderListOn:", "div", "renderButtonsOn:", "setupKeyBindings"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItem:on:",
+protocol: 'rendering',
+fn: function (anObject,html){
+var self=this;
+var li;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$5,$3;
+li=_st(html)._li();
+$1=_st(li)._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._data_put_("item",anObject);
+$2=li;
+_st($2)._class_(self._listCssClassForItem_(anObject));
+$ctx1.sendIdx["class:"]=1;
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(html)._a();
+_st($4)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+_st(_st(html)._tag_("i"))._class_(self._cssClassForItem_(anObject));
+return self._renderItemLabel_on_(anObject,html);
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$5=_st($4)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._reactivateListItem_(_st(li)._asJQuery());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+return $5;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderItem:on:",{anObject:anObject,html:html,li:li},globals.HLListWidget)})},
+args: ["anObject", "html"],
+source: "renderItem: anObject on: html\x0a\x09| li |\x0a    \x0a\x09li := html li.\x0a\x09li asJQuery data: 'item' put: anObject.\x0a    li\x0a\x09\x09class: (self listCssClassForItem: anObject);\x0a        with: [ \x0a        \x09html a\x0a            \x09with: [ \x0a            \x09\x09(html tag: 'i') class: (self cssClassForItem: anObject).\x0a  \x09\x09\x09\x09\x09self renderItemLabel: anObject on: html ];\x0a\x09\x09\x09\x09onClick: [\x0a                  \x09self reactivateListItem: li asJQuery ] ]",
+messageSends: ["li", "data:put:", "asJQuery", "class:", "listCssClassForItem:", "with:", "a", "tag:", "cssClassForItem:", "renderItemLabel:on:", "onClick:", "reactivateListItem:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:on:",
+protocol: 'rendering',
+fn: function (anObject,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(html)._with_(_st(anObject)._asString());
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{anObject:anObject,html:html},globals.HLListWidget)})},
+args: ["anObject", "html"],
+source: "renderItemLabel: anObject on: html\x0a\x09html with: anObject asString",
+messageSends: ["with:", "asString"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderListOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._items())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return self._renderItem_on_(each,html);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderListOn:",{html:html},globals.HLListWidget)})},
+args: ["html"],
+source: "renderListOn: html\x0a\x09self items do: [ :each  | \x0a    \x09self renderItem: each  on: html ]",
+messageSends: ["do:", "items", "renderItem:on:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reselectItem:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return self},
+args: ["anObject"],
+source: "reselectItem: anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectedItem_(anObject);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{anObject:anObject},globals.HLListWidget)})},
+args: ["anObject"],
+source: "selectItem: anObject\x0a\x09self selectedItem: anObject",
+messageSends: ["selectedItem:"],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedItem",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selectedItem"];
+return $1;
+},
+args: [],
+source: "selectedItem\x0a\x09^ selectedItem",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedItem:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@selectedItem"]=anObject;
+return self},
+args: ["anObject"],
+source: "selectedItem: anObject\x0a\x09selectedItem := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupKeyBindings",
+protocol: 'events',
+fn: function (){
+var self=this;
+function $HLRepeatedKeyDownHandler(){return globals.HLRepeatedKeyDownHandler||(typeof HLRepeatedKeyDownHandler=="undefined"?nil:HLRepeatedKeyDownHandler)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+$1=_st($HLRepeatedKeyDownHandler())._on_(self);
+_st($1)._whileKeyDown_do_((38),(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._activatePreviousListItem();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["whileKeyDown:do:"]=1;
+_st($1)._whileKeyDown_do_((40),(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._activateNextListItem();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$2=_st($1)._rebindKeys();
+_st(_st(self._wrapper())._asJQuery())._keydown_((function(e){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(_st(e)._which()).__eq((13));
+if(smalltalk.assert($3)){
+return self._reselectItem_(self._selectedItem());
+};
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,3)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupKeyBindings",{},globals.HLListWidget)})},
+args: [],
+source: "setupKeyBindings \x0a\x09(HLRepeatedKeyDownHandler on: self)\x0a\x09\x09whileKeyDown: 38 do: [ self activatePreviousListItem ];\x0a\x09\x09whileKeyDown: 40 do: [ self activateNextListItem ];\x0a\x09\x09rebindKeys.\x0a\x09\x09\x0a\x09self wrapper asJQuery keydown: [ :e |\x0a        e which = 13 ifTrue: [ \x0a        \x09self reselectItem: self selectedItem ] ]",
+messageSends: ["whileKeyDown:do:", "on:", "activatePreviousListItem", "activateNextListItem", "rebindKeys", "keydown:", "asJQuery", "wrapper", "ifTrue:", "=", "which", "reselectItem:", "selectedItem"],
+referencedClasses: ["HLRepeatedKeyDownHandler"]
+}),
+globals.HLListWidget);
+
+
+
+smalltalk.addClass('HLNavigationListWidget', globals.HLListWidget, ['previous', 'next'], 'Helios-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "next",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@next"];
+return $1;
+},
+args: [],
+source: "next\x0a\x09^ next",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "next:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self["@next"]=aWidget;
+$1=_st(_st(aWidget)._previous()).__eq(self);
+if(! smalltalk.assert($1)){
+_st(aWidget)._previous_(self);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"next:",{aWidget:aWidget},globals.HLNavigationListWidget)})},
+args: ["aWidget"],
+source: "next: aWidget\x0a\x09next := aWidget.\x0a    aWidget previous = self ifFalse: [ aWidget previous: self ]",
+messageSends: ["ifFalse:", "=", "previous", "previous:"],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "nextFocus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self._next();
+$ctx1.sendIdx["next"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+_st(self._next())._focus();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"nextFocus",{},globals.HLNavigationListWidget)})},
+args: [],
+source: "nextFocus\x0a\x09self next ifNotNil: [ self next focus ]",
+messageSends: ["ifNotNil:", "next", "focus"],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previous",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@previous"];
+return $1;
+},
+args: [],
+source: "previous\x0a\x09^ previous",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previous:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self["@previous"]=aWidget;
+$1=_st(_st(aWidget)._next()).__eq(self);
+if(! smalltalk.assert($1)){
+_st(aWidget)._next_(self);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"previous:",{aWidget:aWidget},globals.HLNavigationListWidget)})},
+args: ["aWidget"],
+source: "previous: aWidget\x0a\x09previous := aWidget.\x0a    aWidget next = self ifFalse: [ aWidget next: self ]",
+messageSends: ["ifFalse:", "=", "next", "next:"],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previousFocus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self._previous();
+$ctx1.sendIdx["previous"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+_st(self._previous())._focus();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"previousFocus",{},globals.HLNavigationListWidget)})},
+args: [],
+source: "previousFocus\x0a\x09self previous ifNotNil: [ self previous focus ]",
+messageSends: ["ifNotNil:", "previous", "focus"],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupKeyBindings",
+protocol: 'events',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3;
+($ctx1.supercall = true, globals.HLNavigationListWidget.superclass.fn.prototype._setupKeyBindings.apply(_st(self), []));
+$ctx1.supercall = false;
+_st(_st(self._wrapper())._asJQuery())._keydown_((function(e){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(e)._which();
+$ctx2.sendIdx["which"]=1;
+$1=_st($2).__eq((39));
+$ctx2.sendIdx["="]=1;
+if(smalltalk.assert($1)){
+self._nextFocus();
+};
+$3=_st(_st(e)._which()).__eq((37));
+if(smalltalk.assert($3)){
+return self._previousFocus();
+};
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupKeyBindings",{},globals.HLNavigationListWidget)})},
+args: [],
+source: "setupKeyBindings\x0a\x09super setupKeyBindings.\x0a\x0a\x09self wrapper asJQuery keydown: [ :e |\x0a        e which = 39 ifTrue: [ \x0a        \x09self nextFocus ].\x0a\x09\x09e which = 37 ifTrue: [ \x0a        \x09self previousFocus ] ]",
+messageSends: ["setupKeyBindings", "keydown:", "asJQuery", "wrapper", "ifTrue:", "=", "which", "nextFocus", "previousFocus"],
+referencedClasses: []
+}),
+globals.HLNavigationListWidget);
+
+
+
+smalltalk.addClass('HLToolListWidget', globals.HLNavigationListWidget, ['model'], 'Helios-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateListItem:",
+protocol: 'actions',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._activateListItem_.apply(_st(self), [anItem]));
+$ctx2.supercall = false;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"activateListItem:",{anItem:anItem},globals.HLToolListWidget)})},
+args: ["anItem"],
+source: "activateListItem: anItem\x0a\x09self model withChangesDo: [ super activateListItem: anItem ]",
+messageSends: ["withChangesDo:", "model", "activateListItem:"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateNextListItem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._activateNextListItem.apply(_st(self), []));
+$ctx2.supercall = false;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"activateNextListItem",{},globals.HLToolListWidget)})},
+args: [],
+source: "activateNextListItem\x0a\x09self model withChangesDo: [ super activateNextListItem ]",
+messageSends: ["withChangesDo:", "model", "activateNextListItem"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activatePreviousListItem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._activatePreviousListItem.apply(_st(self), []));
+$ctx2.supercall = false;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"activatePreviousListItem",{},globals.HLToolListWidget)})},
+args: [],
+source: "activatePreviousListItem\x0a\x09self model withChangesDo: [ super activatePreviousListItem ]",
+messageSends: ["withChangesDo:", "model", "activatePreviousListItem"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commandCategory",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"commandCategory",{},globals.HLToolListWidget)})},
+args: [],
+source: "commandCategory\x0a\x09^ self label",
+messageSends: ["label"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "List";
+},
+args: [],
+source: "label\x0a\x09^ 'List'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "menuCommands",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLToolCommand(){return globals.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$1=_st(_st(_st(_st($HLToolCommand())._concreteClasses())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$2=self._model();
+$ctx2.sendIdx["model"]=1;
+return _st(each)._isValidFor_($2);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._for_(self._model());
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})})))._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(_st(each)._category()).__eq(self._commandCategory()))._and_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(each)._isAction())._and_((function(){
+return smalltalk.withContext(function($ctx4) {
+return _st(each)._isActive();
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,5)})}));
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+$ctx2.sendIdx["and:"]=1;
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})}));
+$ctx1.sendIdx["select:"]=1;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"menuCommands",{},globals.HLToolListWidget)})},
+args: [],
+source: "menuCommands\x0a\x09\x22Answer a collection of commands to be put in the cog menu\x22\x0a\x09\x0a\x09^ ((HLToolCommand concreteClasses\x0a\x09\x09select: [ :each | each isValidFor: self model ])\x0a\x09\x09\x09collect: [ :each | each for: self model ])\x0a\x09\x09\x09select: [ :each | \x0a\x09\x09\x09\x09each category = self commandCategory and: [ \x0a\x09\x09\x09\x09\x09each isAction and: [ each isActive ] ] ]",
+messageSends: ["select:", "collect:", "concreteClasses", "isValidFor:", "model", "for:", "and:", "=", "category", "commandCategory", "isAction", "isActive"],
+referencedClasses: ["HLToolCommand"]
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@model"];
+return $1;
+},
+args: [],
+source: "model\x0a\x09^ model",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aBrowserModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self["@model"]=aBrowserModel;
+self._observeSystem();
+$1=self._observeModel();
+return self}, function($ctx1) {$ctx1.fill(self,"model:",{aBrowserModel:aBrowserModel},globals.HLToolListWidget)})},
+args: ["aBrowserModel"],
+source: "model: aBrowserModel\x0a\x09model := aBrowserModel.\x0a    \x0a    self \x0a\x09\x09observeSystem;\x0a\x09\x09observeModel",
+messageSends: ["observeSystem", "observeModel"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "observeModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "observeSystem",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "reactivateListItem:",
+protocol: 'actions',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._reactivateListItem_.apply(_st(self), [anItem]));
+$ctx2.supercall = false;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"reactivateListItem:",{anItem:anItem},globals.HLToolListWidget)})},
+args: ["anItem"],
+source: "reactivateListItem: anItem\x0a\x09self model withChangesDo: [ super reactivateListItem: anItem ]",
+messageSends: ["withChangesDo:", "model", "reactivateListItem:"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._renderHeadOn_(html);
+($ctx1.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLToolListWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09self renderHeadOn: html.\x09\x0a\x09super renderContentOn: html",
+messageSends: ["renderHeadOn:", "renderContentOn:"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderHeadOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("list-label");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+_st(html)._with_(self._label());
+return self._renderMenuOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderHeadOn:",{html:html},globals.HLToolListWidget)})},
+args: ["html"],
+source: "renderHeadOn: html\x0a\x09html div \x0a\x09\x09class: 'list-label';\x0a\x09\x09with: [\x0a\x09\x09\x09html with: self label.\x0a\x09\x09\x09self renderMenuOn: html ]",
+messageSends: ["class:", "div", "with:", "label", "renderMenuOn:"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderMenuOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+var commands;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$5,$6,$8,$9,$7,$3;
+commands=self._menuCommands();
+$ctx1.sendIdx["menuCommands"]=1;
+$1=_st(commands)._isEmpty();
+if(smalltalk.assert($1)){
+return self;
+};
+$2=_st(html)._div();
+_st($2)._class_("btn-group cog");
+$ctx1.sendIdx["class:"]=1;
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(html)._a();
+$ctx2.sendIdx["a"]=1;
+_st($4)._class_("btn dropdown-toggle");
+$ctx2.sendIdx["class:"]=2;
+_st($4)._at_put_("data-toggle","dropdown");
+$5=_st($4)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(html)._tag_("i"))._class_("icon-chevron-down");
+$ctx3.sendIdx["class:"]=3;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+$ctx2.sendIdx["with:"]=2;
+$5;
+$6=_st(html)._ul();
+_st($6)._class_("dropdown-menu pull-right");
+$7=_st($6)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._menuCommands())._do_((function(each){
+return smalltalk.withContext(function($ctx4) {
+return _st(_st(html)._li())._with_((function(){
+return smalltalk.withContext(function($ctx5) {
+$8=_st(html)._a();
+_st($8)._with_(_st(each)._menuLabel());
+$9=_st($8)._onClick_((function(){
+return smalltalk.withContext(function($ctx6) {
+return self._execute_(each);
+}, function($ctx6) {$ctx6.fillBlock({},$ctx5,7)})}));
+return $9;
+}, function($ctx5) {$ctx5.fillBlock({},$ctx4,6)})}));
+$ctx4.sendIdx["with:"]=4;
+}, function($ctx4) {$ctx4.fillBlock({each:each},$ctx3,5)})}));
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+$ctx2.sendIdx["with:"]=3;
+return $7;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderMenuOn:",{html:html,commands:commands},globals.HLToolListWidget)})},
+args: ["html"],
+source: "renderMenuOn: html\x0a\x09| commands |\x0a\x09\x0a\x09commands := self menuCommands.\x0a\x09commands isEmpty ifTrue: [ ^ self ].\x0a\x09\x0a\x09html div \x0a\x09\x09class: 'btn-group cog';\x0a\x09\x09with: [\x0a\x09\x09\x09html a\x0a\x09\x09\x09\x09class: 'btn dropdown-toggle';\x0a\x09\x09\x09\x09at: 'data-toggle' put: 'dropdown';\x0a\x09\x09\x09\x09with: [ (html tag: 'i') class: 'icon-chevron-down' ].\x0a\x09\x09html ul \x0a\x09\x09\x09class: 'dropdown-menu pull-right';\x0a\x09\x09\x09with: [ \x0a\x09\x09\x09\x09self menuCommands do: [ :each | \x0a\x09\x09\x09\x09\x09html li with: [ html a \x0a\x09\x09\x09\x09\x09\x09with: each menuLabel;\x0a\x09\x09\x09\x09\x09\x09onClick: [ self execute: each ] ] ] ] ]",
+messageSends: ["menuCommands", "ifTrue:", "isEmpty", "class:", "div", "with:", "a", "at:put:", "tag:", "ul", "do:", "li", "menuLabel", "onClick:", "execute:"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedItem:",
+protocol: 'accessing',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._selectedItem_.apply(_st(self), [anItem]));
+$ctx1.supercall = false;
+self._updateMenu();
+return self}, function($ctx1) {$ctx1.fill(self,"selectedItem:",{anItem:anItem},globals.HLToolListWidget)})},
+args: ["anItem"],
+source: "selectedItem: anItem\x0a\x09\x22Selection changed, update the cog menu\x22\x0a\x09\x0a\x09super selectedItem: anItem.\x0a\x09self updateMenu",
+messageSends: ["selectedItem:", "updateMenu"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+($ctx1.supercall = true, globals.HLToolListWidget.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+$2=self._model();
+$ctx1.sendIdx["model"]=1;
+$1=_st($2)._announcer();
+_st($1)._unsubscribe_(self);
+$ctx1.sendIdx["unsubscribe:"]=1;
+_st(_st(self._model())._systemAnnouncer())._unsubscribe_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLToolListWidget)})},
+args: [],
+source: "unregister\x0a\x09super unregister.\x0a\x09\x0a\x09self model announcer unsubscribe: self.\x0a\x09self model systemAnnouncer unsubscribe: self",
+messageSends: ["unregister", "unsubscribe:", "announcer", "model", "systemAnnouncer"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateMenu",
+protocol: 'updating',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1;
+$3=self._wrapper();
+$ctx1.sendIdx["wrapper"]=1;
+$2=_st($3)._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+$1=_st($2)._find_(".cog");
+$ctx1.sendIdx["find:"]=1;
+_st($1)._remove();
+_st((function(html){
+return smalltalk.withContext(function($ctx2) {
+return self._renderMenuOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)})}))._appendToJQuery_(_st(_st(self._wrapper())._asJQuery())._find_(".list-label"));
+return self}, function($ctx1) {$ctx1.fill(self,"updateMenu",{},globals.HLToolListWidget)})},
+args: [],
+source: "updateMenu\x0a\x09(self wrapper asJQuery find: '.cog') remove.\x0a\x09\x0a\x09[ :html | self renderMenuOn: html ] \x0a\x09\x09appendToJQuery: (self wrapper asJQuery find: '.list-label')",
+messageSends: ["remove", "find:", "asJQuery", "wrapper", "appendToJQuery:", "renderMenuOn:"],
+referencedClasses: []
+}),
+globals.HLToolListWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._model_(aModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aModel:aModel},globals.HLToolListWidget.klass)})},
+args: ["aModel"],
+source: "on: aModel\x0a\x09^ self new \x0a    \x09model: aModel;\x0a        yourself",
+messageSends: ["model:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLToolListWidget.klass);
+
+
+smalltalk.addClass('HLTabListWidget', globals.HLListWidget, ['callback'], 'Helios-Core');
+globals.HLTabListWidget.comment="I am a widget used to display a list of helios tabs.\x0a\x0aWhen a tab is selected, `callback` is evaluated with the selected tab as argument.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "callback",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@callback"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=(function(){
+});
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"callback",{},globals.HLTabListWidget)})},
+args: [],
+source: "callback\x0a\x09^ callback ifNil: [ [] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "callback:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@callback"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "callback: aBlock\x0a\x09callback := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:on:",
+protocol: 'rendering',
+fn: function (aTab,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._span();
+_st($1)._class_(_st(aTab)._cssClass());
+$2=_st($1)._with_(_st(aTab)._label());
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aTab:aTab,html:html},globals.HLTabListWidget)})},
+args: ["aTab", "html"],
+source: "renderItemLabel: aTab on: html\x0a\x09html span\x0a\x09\x09class: aTab cssClass;\x0a\x09\x09with: aTab label",
+messageSends: ["class:", "span", "cssClass", "with:", "label"],
+referencedClasses: []
+}),
+globals.HLTabListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLTabListWidget.superclass.fn.prototype._selectItem_.apply(_st(self), [aTab]));
+$ctx1.supercall = false;
+_st(self._callback())._value_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aTab:aTab},globals.HLTabListWidget)})},
+args: ["aTab"],
+source: "selectItem: aTab\x0a\x09super selectItem: aTab.\x0a\x09self callback value: aTab",
+messageSends: ["selectItem:", "value:", "callback"],
+referencedClasses: []
+}),
+globals.HLTabListWidget);
+
+
+
+smalltalk.addClass('HLInformationWidget', globals.HLWidget, ['informationString'], 'Helios-Core');
+globals.HLInformationWidget.comment="I display an information dialog.\x0a\x0a## API\x0a\x0a`HLWidget >> #inform:` is a convenience method for creating information dialogs.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "informationString",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@informationString"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"informationString",{},globals.HLInformationWidget)})},
+args: [],
+source: "informationString\x0a\x09^ informationString ifNil: [ '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLInformationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "informationString:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@informationString"]=anObject;
+return self},
+args: ["anObject"],
+source: "informationString: anObject\x0a\x09informationString := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInformationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "remove",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+$2=self._wrapper();
+$ctx2.sendIdx["wrapper"]=1;
+$1=_st($2)._asJQuery();
+$ctx2.sendIdx["asJQuery"]=1;
+_st($1)._fadeOut_((100));
+return _st((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(self._wrapper())._asJQuery())._remove();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}))._valueWithTimeout_((400));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._valueWithTimeout_((1500));
+$ctx1.sendIdx["valueWithTimeout:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"remove",{},globals.HLInformationWidget)})},
+args: [],
+source: "remove\x0a\x09[ \x0a\x09\x09self wrapper asJQuery fadeOut: 100.\x0a\x09\x09[ self wrapper asJQuery remove ]\x0a\x09\x09\x09valueWithTimeout: 400.\x0a\x09]\x0a\x09\x09valueWithTimeout: 1500",
+messageSends: ["valueWithTimeout:", "fadeOut:", "asJQuery", "wrapper", "remove"],
+referencedClasses: []
+}),
+globals.HLInformationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("growl");
+$2=_st($1)._with_(self._informationString());
+self._remove();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLInformationWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html div \x0a\x09\x09class: 'growl'; \x0a\x09\x09with: self informationString.\x0a\x09\x09\x0a\x09self remove",
+messageSends: ["class:", "div", "with:", "informationString", "remove"],
+referencedClasses: []
+}),
+globals.HLInformationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._appendToJQuery_("body"._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"show",{},globals.HLInformationWidget)})},
+args: [],
+source: "show\x0a\x09self appendToJQuery: 'body' asJQuery",
+messageSends: ["appendToJQuery:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLInformationWidget);
+
+
+
+smalltalk.addClass('HLManager', globals.HLWidget, ['tabsWidget', 'environment', 'history', 'announcer'], 'Helios-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activate:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._tabsWidget())._activate_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"activate:",{aTab:aTab},globals.HLManager)})},
+args: ["aTab"],
+source: "activate: aTab\x0a\x09self tabsWidget activate: aTab",
+messageSends: ["activate:", "tabsWidget"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activeTab",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._tabsWidget())._activeTab();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"activeTab",{},globals.HLManager)})},
+args: [],
+source: "activeTab\x0a\x09^ self tabsWidget activeTab",
+messageSends: ["activeTab", "tabsWidget"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addTab:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._tabsWidget())._addTab_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"addTab:",{aTab:aTab},globals.HLManager)})},
+args: ["aTab"],
+source: "addTab: aTab\x0a\x09self tabsWidget addTab: aTab",
+messageSends: ["addTab:", "tabsWidget"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "announcer",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Announcer(){return globals.Announcer||(typeof Announcer=="undefined"?nil:Announcer)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@announcer"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@announcer"]=_st($Announcer())._new();
+$1=self["@announcer"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"announcer",{},globals.HLManager)})},
+args: [],
+source: "announcer\x0a\x09^ announcer ifNil: [ announcer := Announcer new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["Announcer"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm:ifFalse:",
+protocol: 'actions',
+fn: function (aString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._confirm_ifTrue_ifFalse_(aString,(function(){
+}),aBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"confirm:ifFalse:",{aString:aString,aBlock:aBlock},globals.HLManager)})},
+args: ["aString", "aBlock"],
+source: "confirm: aString ifFalse: aBlock\x0a\x09self \x0a\x09\x09confirm: aString\x0a\x09\x09ifTrue: []\x0a\x09\x09ifFalse: aBlock",
+messageSends: ["confirm:ifTrue:ifFalse:"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm:ifTrue:",
+protocol: 'actions',
+fn: function (aString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._confirm_ifTrue_ifFalse_(aString,aBlock,(function(){
+}));
+return self}, function($ctx1) {$ctx1.fill(self,"confirm:ifTrue:",{aString:aString,aBlock:aBlock},globals.HLManager)})},
+args: ["aString", "aBlock"],
+source: "confirm: aString ifTrue: aBlock\x0a\x09self \x0a\x09\x09confirm: aString\x0a\x09\x09ifTrue: aBlock\x0a\x09\x09ifFalse: []",
+messageSends: ["confirm:ifTrue:ifFalse:"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm:ifTrue:ifFalse:",
+protocol: 'actions',
+fn: function (aString,aBlock,anotherBlock){
+var self=this;
+function $HLConfirmationWidget(){return globals.HLConfirmationWidget||(typeof HLConfirmationWidget=="undefined"?nil:HLConfirmationWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLConfirmationWidget())._new();
+_st($1)._confirmationString_(aString);
+_st($1)._actionBlock_(aBlock);
+_st($1)._cancelBlock_(anotherBlock);
+$2=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"confirm:ifTrue:ifFalse:",{aString:aString,aBlock:aBlock,anotherBlock:anotherBlock},globals.HLManager)})},
+args: ["aString", "aBlock", "anotherBlock"],
+source: "confirm: aString ifTrue: aBlock ifFalse: anotherBlock\x0a\x09HLConfirmationWidget new\x0a\x09\x09confirmationString: aString;\x0a\x09\x09actionBlock: aBlock;\x0a\x09\x09cancelBlock: anotherBlock;\x0a\x09\x09show",
+messageSends: ["confirmationString:", "new", "actionBlock:", "cancelBlock:", "show"],
+referencedClasses: ["HLConfirmationWidget"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultEnvironment",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+var parent,parentSmalltalkGlobals;
+function $Environment(){return globals.Environment||(typeof Environment=="undefined"?nil:Environment)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5,$6,$7,$receiver;
+$1=_st(window)._opener();
+if(($receiver = $1) == null || $receiver.isNil){
+parent=_st(window)._parent();
+} else {
+parent=$1;
+};
+$2=parent;
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($Environment())._new();
+$ctx1.sendIdx["new"]=1;
+return $3;
+} else {
+$2;
+};
+$4=_st(parent)._at_("requirejs");
+$ctx1.sendIdx["at:"]=1;
+parentSmalltalkGlobals=_st($4)._value_("amber_vm/globals");
+$5=parentSmalltalkGlobals;
+if(($receiver = $5) == null || $receiver.isNil){
+$6=_st($Environment())._new();
+$ctx1.sendIdx["new"]=2;
+return $6;
+} else {
+$5;
+};
+$7=_st(_st(parentSmalltalkGlobals)._at_("Environment"))._new();
+return $7;
+}, function($ctx1) {$ctx1.fill(self,"defaultEnvironment",{parent:parent,parentSmalltalkGlobals:parentSmalltalkGlobals},globals.HLManager)})},
+args: [],
+source: "defaultEnvironment\x0a\x09\x22If helios is loaded from within a frame, answer the parent window environment\x22\x0a\x09\x0a\x09| parent parentSmalltalkGlobals |\x0a\x09\x0a\x09parent := window opener ifNil: [ window parent ].\x0a\x09parent ifNil: [ ^ Environment new ].\x0a\x09\x0a\x09parentSmalltalkGlobals := (parent at: 'requirejs') value: 'amber_vm/globals'.\x0a\x09parentSmalltalkGlobals ifNil: [ ^ Environment new ].\x0a\x09\x0a\x09^ (parentSmalltalkGlobals at: 'Environment') new",
+messageSends: ["ifNil:", "opener", "parent", "new", "value:", "at:"],
+referencedClasses: ["Environment"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@environment"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@environment"]=self._defaultEnvironment();
+$1=self["@environment"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"environment",{},globals.HLManager)})},
+args: [],
+source: "environment\x0a\x09\x22The default environment used by all Helios objects\x22\x0a    \x0a\x09^ environment ifNil: [ environment := self defaultEnvironment ]",
+messageSends: ["ifNil:", "defaultEnvironment"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment:",
+protocol: 'accessing',
+fn: function (anEnvironment){
+var self=this;
+self["@environment"]=anEnvironment;
+return self},
+args: ["anEnvironment"],
+source: "environment: anEnvironment\x0a\x09environment := anEnvironment",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "history",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@history"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@history"]=_st($OrderedCollection())._new();
+$1=self["@history"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"history",{},globals.HLManager)})},
+args: [],
+source: "history\x0a\x09^ history ifNil: [ history := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "history:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@history"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "history: aCollection\x0a\x09history := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inform:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $HLInformationWidget(){return globals.HLInformationWidget||(typeof HLInformationWidget=="undefined"?nil:HLInformationWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLInformationWidget())._new();
+_st($1)._informationString_(aString);
+$2=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"inform:",{aString:aString},globals.HLManager)})},
+args: ["aString"],
+source: "inform: aString\x0a\x09HLInformationWidget new\x0a\x09\x09informationString: aString;\x0a\x09\x09show",
+messageSends: ["informationString:", "new", "show"],
+referencedClasses: ["HLInformationWidget"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "keyBinder",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLKeyBinder(){return globals.HLKeyBinder||(typeof HLKeyBinder=="undefined"?nil:HLKeyBinder)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLKeyBinder())._current();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"keyBinder",{},globals.HLManager)})},
+args: [],
+source: "keyBinder\x0a\x09^ HLKeyBinder current",
+messageSends: ["current"],
+referencedClasses: ["HLKeyBinder"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerErrorHandler",
+protocol: 'services',
+fn: function (){
+var self=this;
+function $HLErrorHandler(){return globals.HLErrorHandler||(typeof HLErrorHandler=="undefined"?nil:HLErrorHandler)}
+function $ErrorHandler(){return globals.ErrorHandler||(typeof ErrorHandler=="undefined"?nil:ErrorHandler)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._environment();
+$2=_st($HLErrorHandler())._new();
+$ctx1.sendIdx["new"]=1;
+_st($1)._registerErrorHandler_($2);
+_st($ErrorHandler())._register_(_st($HLErrorHandler())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"registerErrorHandler",{},globals.HLManager)})},
+args: [],
+source: "registerErrorHandler\x0a\x09self environment registerErrorHandler: HLErrorHandler new.\x0a\x09ErrorHandler register: HLErrorHandler new",
+messageSends: ["registerErrorHandler:", "environment", "new", "register:"],
+referencedClasses: ["HLErrorHandler", "ErrorHandler"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerFinder",
+protocol: 'services',
+fn: function (){
+var self=this;
+function $HLFinder(){return globals.HLFinder||(typeof HLFinder=="undefined"?nil:HLFinder)}
+function $Finder(){return globals.Finder||(typeof Finder=="undefined"?nil:Finder)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._environment();
+$2=_st($HLFinder())._new();
+$ctx1.sendIdx["new"]=1;
+_st($1)._registerFinder_($2);
+_st($Finder())._register_(_st($HLFinder())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"registerFinder",{},globals.HLManager)})},
+args: [],
+source: "registerFinder\x0a\x09self environment registerFinder: HLFinder new.\x0a\x09Finder register: HLFinder new",
+messageSends: ["registerFinder:", "environment", "new", "register:"],
+referencedClasses: ["HLFinder", "Finder"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerInspector",
+protocol: 'services',
+fn: function (){
+var self=this;
+function $HLInspector(){return globals.HLInspector||(typeof HLInspector=="undefined"?nil:HLInspector)}
+function $Inspector(){return globals.Inspector||(typeof Inspector=="undefined"?nil:Inspector)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._registerInspector_($HLInspector());
+_st($Inspector())._register_($HLInspector());
+return self}, function($ctx1) {$ctx1.fill(self,"registerInspector",{},globals.HLManager)})},
+args: [],
+source: "registerInspector\x0a\x09self environment registerInspector: HLInspector.\x0a\x09Inspector register: HLInspector",
+messageSends: ["registerInspector:", "environment", "register:"],
+referencedClasses: ["HLInspector", "Inspector"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerProgressHandler",
+protocol: 'services',
+fn: function (){
+var self=this;
+function $HLProgressHandler(){return globals.HLProgressHandler||(typeof HLProgressHandler=="undefined"?nil:HLProgressHandler)}
+function $ProgressHandler(){return globals.ProgressHandler||(typeof ProgressHandler=="undefined"?nil:ProgressHandler)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._environment();
+$2=_st($HLProgressHandler())._new();
+$ctx1.sendIdx["new"]=1;
+_st($1)._registerProgressHandler_($2);
+_st($ProgressHandler())._register_(_st($HLProgressHandler())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"registerProgressHandler",{},globals.HLManager)})},
+args: [],
+source: "registerProgressHandler\x0a\x09self environment registerProgressHandler: HLProgressHandler new.\x0a\x09ProgressHandler register: HLProgressHandler new",
+messageSends: ["registerProgressHandler:", "environment", "new", "register:"],
+referencedClasses: ["HLProgressHandler", "ProgressHandler"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerServices",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._registerInspector();
+self._registerErrorHandler();
+self._registerProgressHandler();
+self._registerTranscript();
+$1=self._registerFinder();
+return self}, function($ctx1) {$ctx1.fill(self,"registerServices",{},globals.HLManager)})},
+args: [],
+source: "registerServices\x0a\x09self\x0a\x09\x09registerInspector;\x0a\x09\x09registerErrorHandler;\x0a\x09\x09registerProgressHandler;\x0a\x09\x09registerTranscript;\x0a\x09\x09registerFinder",
+messageSends: ["registerInspector", "registerErrorHandler", "registerProgressHandler", "registerTranscript", "registerFinder"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerTranscript",
+protocol: 'services',
+fn: function (){
+var self=this;
+function $HLTranscriptHandler(){return globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._registerTranscript_($HLTranscriptHandler());
+return self}, function($ctx1) {$ctx1.fill(self,"registerTranscript",{},globals.HLManager)})},
+args: [],
+source: "registerTranscript\x0a\x09self environment registerTranscript: HLTranscriptHandler",
+messageSends: ["registerTranscript:", "environment"],
+referencedClasses: ["HLTranscriptHandler"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeActiveTab",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._tabsWidget())._removeActiveTab();
+return self}, function($ctx1) {$ctx1.fill(self,"removeActiveTab",{},globals.HLManager)})},
+args: [],
+source: "removeActiveTab\x0a\x09self tabsWidget removeActiveTab",
+messageSends: ["removeActiveTab", "tabsWidget"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeTabForWidget:",
+protocol: 'actions',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._tabsWidget())._removeTabForWidget_(aWidget);
+return self}, function($ctx1) {$ctx1.fill(self,"removeTabForWidget:",{aWidget:aWidget},globals.HLManager)})},
+args: ["aWidget"],
+source: "removeTabForWidget: aWidget\x0a\x09self tabsWidget removeTabForWidget: aWidget",
+messageSends: ["removeTabForWidget:", "tabsWidget"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLWelcomeWidget(){return globals.HLWelcomeWidget||(typeof HLWelcomeWidget=="undefined"?nil:HLWelcomeWidget)}
+return smalltalk.withContext(function($ctx1) { 
+_st(html)._with_(self._tabsWidget());
+$ctx1.sendIdx["with:"]=1;
+_st(html)._with_(_st($HLWelcomeWidget())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLManager)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html with: self tabsWidget.\x0a\x09html with: HLWelcomeWidget new",
+messageSends: ["with:", "tabsWidget", "new"],
+referencedClasses: ["HLWelcomeWidget"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "request:do:",
+protocol: 'actions',
+fn: function (aString,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._request_value_do_(aString,"",aBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"request:do:",{aString:aString,aBlock:aBlock},globals.HLManager)})},
+args: ["aString", "aBlock"],
+source: "request: aString do: aBlock\x0a\x09self \x0a\x09\x09request: aString\x0a\x09\x09value: ''\x0a\x09\x09do: aBlock",
+messageSends: ["request:value:do:"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "request:value:do:",
+protocol: 'actions',
+fn: function (aString,valueString,aBlock){
+var self=this;
+function $HLRequestWidget(){return globals.HLRequestWidget||(typeof HLRequestWidget=="undefined"?nil:HLRequestWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLRequestWidget())._new();
+_st($1)._confirmationString_(aString);
+_st($1)._actionBlock_(aBlock);
+_st($1)._value_(valueString);
+$2=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"request:value:do:",{aString:aString,valueString:valueString,aBlock:aBlock},globals.HLManager)})},
+args: ["aString", "valueString", "aBlock"],
+source: "request: aString value: valueString do: aBlock\x0a\x09HLRequestWidget new\x0a\x09\x09confirmationString: aString;\x0a\x09\x09actionBlock: aBlock;\x0a\x09\x09value: valueString;\x0a\x09\x09show",
+messageSends: ["confirmationString:", "new", "actionBlock:", "value:", "show"],
+referencedClasses: ["HLRequestWidget"]
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setEditorTheme:",
+protocol: 'accessing',
+fn: function (aTheme){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st("helios.editorTheme"._asSetting())._value_(aTheme);
+return self}, function($ctx1) {$ctx1.fill(self,"setEditorTheme:",{aTheme:aTheme},globals.HLManager)})},
+args: ["aTheme"],
+source: "setEditorTheme: aTheme\x0a\x0a\x09'helios.editorTheme' asSetting value: aTheme",
+messageSends: ["value:", "asSetting"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setTheme:",
+protocol: 'accessing',
+fn: function (aTheme){
+var self=this;
+var currentTheme;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+currentTheme="helios.theme"._asSettingIfAbsent_("default");
+$1="body"._asJQuery();
+_st($1)._removeClass_(_st(currentTheme)._value());
+$2=_st($1)._addClass_(aTheme);
+_st("helios.theme"._asSetting())._value_(aTheme);
+return self}, function($ctx1) {$ctx1.fill(self,"setTheme:",{aTheme:aTheme,currentTheme:currentTheme},globals.HLManager)})},
+args: ["aTheme"],
+source: "setTheme: aTheme\x0a\x09| currentTheme |\x0a\x0a\x09currentTheme := 'helios.theme' asSettingIfAbsent: 'default'.\x0a\x09\x0a\x09'body' asJQuery\x0a\x09\x09removeClass: currentTheme value;\x0a\x09\x09addClass: aTheme.\x0a\x09\x09\x0a\x09\x0a\x09'helios.theme' asSetting value: aTheme",
+messageSends: ["asSettingIfAbsent:", "removeClass:", "asJQuery", "value", "addClass:", "value:", "asSetting"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setup",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._registerServices();
+$1=self._setupEvents();
+$ctx1.sendIdx["setupEvents"]=1;
+_st(self._keyBinder())._setupEvents();
+$ctx1.sendIdx["setupEvents"]=2;
+_st(self._tabsWidget())._setupEvents();
+self._setupTheme();
+_st("#helper"._asJQuery())._fadeOut();
+return self}, function($ctx1) {$ctx1.fill(self,"setup",{},globals.HLManager)})},
+args: [],
+source: "setup\x0a\x09self \x0a\x09\x09registerServices;\x0a\x09\x09setupEvents.\x0a    self keyBinder setupEvents.\x0a\x09self tabsWidget setupEvents.\x0a\x09self setupTheme.\x0a\x09\x0a\x09\x0a\x09'#helper' asJQuery fadeOut",
+messageSends: ["registerServices", "setupEvents", "keyBinder", "tabsWidget", "setupTheme", "fadeOut", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupEvents",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5;
+$1="body"._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._keydown_((function(event){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(event)._ctrlKey();
+if(smalltalk.assert($2)){
+$3="body"._asJQuery();
+$ctx2.sendIdx["asJQuery"]=2;
+return _st($3)._addClass_("navigation");
+};
+}, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1,1)})}));
+$4="body"._asJQuery();
+$ctx1.sendIdx["asJQuery"]=3;
+_st($4)._keyup_((function(event){
+return smalltalk.withContext(function($ctx2) {
+$5="body"._asJQuery();
+$ctx2.sendIdx["asJQuery"]=4;
+return _st($5)._removeClass_("navigation");
+}, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1,3)})}));
+_st(_st(window)._asJQuery())._resize_((function(event){
+return smalltalk.withContext(function($ctx2) {
+return self._refresh();
+}, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1,4)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupEvents",{},globals.HLManager)})},
+args: [],
+source: "setupEvents\x0a\x09'body' asJQuery keydown: [ :event |\x0a\x09\x09\x09\x0a\x09\x09\x22On ctrl keydown, adds a 'navigation' css class to <body>\x0a\x09\x09for the CodeMirror navigation links. See `HLCodeWidget`.\x22\x0a\x09\x09event ctrlKey ifTrue: [\x0a\x09\x09\x09'body' asJQuery addClass: 'navigation' ] ].\x0a\x09\x09\x09\x0a\x09'body' asJQuery keyup: [ :event |\x0a\x09\x09'body' asJQuery removeClass: 'navigation' ].\x0a\x09\x09\x0a\x09window asJQuery resize: [ :event |\x0a\x09\x09self refresh ]",
+messageSends: ["keydown:", "asJQuery", "ifTrue:", "ctrlKey", "addClass:", "keyup:", "removeClass:", "resize:", "refresh"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupTheme",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._setTheme_("default");
+$1=self._setEditorTheme_("default");
+return self}, function($ctx1) {$ctx1.fill(self,"setupTheme",{},globals.HLManager)})},
+args: [],
+source: "setupTheme\x0a\x09\x22self \x0a\x09\x09setTheme: 'niflheim';\x0a\x09\x09setEditorTheme: 'niflheim'.\x22\x0a\x09\x09\x0a\x09self \x0a\x09\x09setTheme: 'default';\x0a\x09\x09setEditorTheme: 'default'.",
+messageSends: ["setTheme:", "setEditorTheme:"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabWidth",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(_st(window)._asJQuery())._width()).__minus((90))).__slash(_st(self._tabs())._size());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabWidth",{},globals.HLManager)})},
+args: [],
+source: "tabWidth\x0a\x09^ (window asJQuery width - 90) / self tabs size",
+messageSends: ["/", "-", "width", "asJQuery", "size", "tabs"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabs",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._tabsWidget())._tabs();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabs",{},globals.HLManager)})},
+args: [],
+source: "tabs\x0a\x09^ self tabsWidget tabs",
+messageSends: ["tabs", "tabsWidget"],
+referencedClasses: []
+}),
+globals.HLManager);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabsWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLTabsWidget(){return globals.HLTabsWidget||(typeof HLTabsWidget=="undefined"?nil:HLTabsWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@tabsWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@tabsWidget"]=_st($HLTabsWidget())._new();
+$1=self["@tabsWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabsWidget",{},globals.HLManager)})},
+args: [],
+source: "tabsWidget\x0a\x09^ tabsWidget ifNil: [ tabsWidget := HLTabsWidget new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HLTabsWidget"]
+}),
+globals.HLManager);
+
+
+globals.HLManager.klass.iVarNames = ['current'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "current",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@current"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@current"]=_st(self._basicNew())._initialize();
+$1=self["@current"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"current",{},globals.HLManager.klass)})},
+args: [],
+source: "current\x0a\x09^ current ifNil: [ current := self basicNew initialize ]",
+messageSends: ["ifNil:", "initialize", "basicNew"],
+referencedClasses: []
+}),
+globals.HLManager.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "new",
+protocol: 'instance creation',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._shouldNotImplement();
+return self}, function($ctx1) {$ctx1.fill(self,"new",{},globals.HLManager.klass)})},
+args: [],
+source: "new\x0a\x09\x22Use current instead\x22\x0a\x0a\x09self shouldNotImplement",
+messageSends: ["shouldNotImplement"],
+referencedClasses: []
+}),
+globals.HLManager.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setup",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._current();
+_st($1)._setup();
+$2=_st($1)._appendToJQuery_("body"._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"setup",{},globals.HLManager.klass)})},
+args: [],
+source: "setup\x0a\x09self current \x0a\x09\x09setup;\x0a\x09\x09appendToJQuery: 'body' asJQuery",
+messageSends: ["setup", "current", "appendToJQuery:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLManager.klass);
+
+
+smalltalk.addClass('HLModalWidget', globals.HLWidget, [], 'Helios-Core');
+globals.HLModalWidget.comment="I implement an abstract modal widget.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "giveFocusToButton:",
+protocol: 'private',
+fn: function (aButton){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(aButton)._asJQuery())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"giveFocusToButton:",{aButton:aButton},globals.HLModalWidget)})},
+args: ["aButton"],
+source: "giveFocusToButton: aButton\x0a\x09aButton asJQuery focus",
+messageSends: ["focus", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hasButtons",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "hasButtons\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "remove",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=".dialog"._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._removeClass_("active");
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+$2="#overlay"._asJQuery();
+$ctx2.sendIdx["asJQuery"]=2;
+_st($2)._remove();
+$ctx2.sendIdx["remove"]=1;
+return _st(_st(self["@wrapper"])._asJQuery())._remove();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._valueWithTimeout_((300));
+return self}, function($ctx1) {$ctx1.fill(self,"remove",{},globals.HLModalWidget)})},
+args: [],
+source: "remove\x0a\x09'.dialog' asJQuery removeClass: 'active'.\x0a\x09[ \x0a\x09\x09'#overlay' asJQuery remove.\x0a\x09\x09wrapper asJQuery remove\x0a\x09] valueWithTimeout: 300",
+messageSends: ["removeClass:", "asJQuery", "valueWithTimeout:", "remove"],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return self},
+args: ["html"],
+source: "renderButtonsOn: html",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+var confirmButton;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._id_("overlay");
+$2=_st(html)._div();
+_st($2)._class_("dialog ".__comma(self._cssClass()));
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._renderMainOn_(html);
+$4=self._hasButtons();
+if(smalltalk.assert($4)){
+return self._renderButtonsOn_(html);
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+_st(".dialog"._asJQuery())._addClass_("active");
+self._setupKeyBindings();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html,confirmButton:confirmButton},globals.HLModalWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09| confirmButton |\x0a\x09\x0a\x09html div id: 'overlay'.\x0a\x09\x0a\x09html div \x0a\x09\x09class: 'dialog ', self cssClass;\x0a\x09\x09with: [\x0a\x09\x09\x09self renderMainOn: html.\x0a\x09\x09\x09self hasButtons ifTrue: [ \x0a\x09\x09\x09\x09self renderButtonsOn: html ] ].\x0a\x0a\x09'.dialog' asJQuery addClass: 'active'.\x0a\x09self setupKeyBindings",
+messageSends: ["id:", "div", "class:", ",", "cssClass", "with:", "renderMainOn:", "ifTrue:", "hasButtons", "renderButtonsOn:", "addClass:", "asJQuery", "setupKeyBindings"],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderMainOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return self},
+args: ["html"],
+source: "renderMainOn: html",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupKeyBindings",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(".dialog"._asJQuery())._keyup_((function(e){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(_st(e)._keyCode()).__eq(_st(_st($String())._esc())._asciiValue());
+if(smalltalk.assert($1)){
+return self._cancel();
+};
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupKeyBindings",{},globals.HLModalWidget)})},
+args: [],
+source: "setupKeyBindings\x0a\x09'.dialog' asJQuery keyup: [ :e |\x0a\x09\x09e keyCode = String esc asciiValue ifTrue: [ self cancel ] ]",
+messageSends: ["keyup:", "asJQuery", "ifTrue:", "=", "keyCode", "asciiValue", "esc", "cancel"],
+referencedClasses: ["String"]
+}),
+globals.HLModalWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._appendToJQuery_("body"._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"show",{},globals.HLModalWidget)})},
+args: [],
+source: "show\x0a\x09self appendToJQuery: 'body' asJQuery",
+messageSends: ["appendToJQuery:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLModalWidget);
+
+
+
+smalltalk.addClass('HLConfirmationWidget', globals.HLModalWidget, ['cancelButtonLabel', 'confirmButtonLabel', 'confirmationString', 'actionBlock', 'cancelBlock'], 'Helios-Core');
+globals.HLConfirmationWidget.comment="I display confirmation dialog. \x0a\x0a## API\x0a\x0aHLWidget contains convenience methods like `HLWidget >> #confirm:ifTrue:` for creating confirmation dialogs.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "actionBlock",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@actionBlock"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=(function(){
+});
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"actionBlock",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "actionBlock\x0a\x09^ actionBlock ifNil: [ [] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "actionBlock:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@actionBlock"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "actionBlock: aBlock\x0a\x09actionBlock := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._cancelBlock())._value();
+self._remove();
+return self}, function($ctx1) {$ctx1.fill(self,"cancel",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "cancel\x0a\x09self cancelBlock value.\x0a\x09self remove",
+messageSends: ["value", "cancelBlock", "remove"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancelBlock",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@cancelBlock"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=(function(){
+});
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cancelBlock",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "cancelBlock\x0a\x09^ cancelBlock ifNil: [ [] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancelBlock:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@cancelBlock"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "cancelBlock: aBlock\x0a\x09cancelBlock := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancelButtonLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@cancelButtonLabel"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="Cancel";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cancelButtonLabel",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "cancelButtonLabel\x0a\x09^ cancelButtonLabel ifNil: [ 'Cancel' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancelButtonLabel:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+var $1;
+self["@cancelButtonLabel"]=aString;
+$1=self["@cancelButtonLabel"];
+return $1;
+},
+args: ["aString"],
+source: "cancelButtonLabel: aString\x0a\x09^ cancelButtonLabel := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._remove();
+_st(self._actionBlock())._value();
+return self}, function($ctx1) {$ctx1.fill(self,"confirm",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "confirm\x0a\x09self remove.\x0a\x09self actionBlock value",
+messageSends: ["remove", "value", "actionBlock"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmButtonLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@confirmButtonLabel"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="Confirm";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"confirmButtonLabel",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "confirmButtonLabel\x0a\x09^ confirmButtonLabel ifNil: [ 'Confirm' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmButtonLabel:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+var $1;
+self["@confirmButtonLabel"]=aString;
+$1=self["@confirmButtonLabel"];
+return $1;
+},
+args: ["aString"],
+source: "confirmButtonLabel: aString\x0a\x09^ confirmButtonLabel := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmationString",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@confirmationString"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="Confirm";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"confirmationString",{},globals.HLConfirmationWidget)})},
+args: [],
+source: "confirmationString\x0a\x09^ confirmationString ifNil: [ 'Confirm' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmationString:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@confirmationString"]=aString;
+return self},
+args: ["aString"],
+source: "confirmationString: aString\x0a\x09confirmationString := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+var confirmButton;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$5,$6,$2;
+$1=_st(html)._div();
+_st($1)._class_("buttons");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._button();
+$ctx2.sendIdx["button"]=1;
+_st($3)._class_("button");
+$ctx2.sendIdx["class:"]=2;
+_st($3)._with_(self._cancelButtonLabel());
+$ctx2.sendIdx["with:"]=2;
+$4=_st($3)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._cancel();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$ctx2.sendIdx["onClick:"]=1;
+$4;
+$5=_st(html)._button();
+_st($5)._class_("button default");
+_st($5)._with_(self._confirmButtonLabel());
+$6=_st($5)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._confirm();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+confirmButton=$6;
+return confirmButton;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+self._giveFocusToButton_(confirmButton);
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html,confirmButton:confirmButton},globals.HLConfirmationWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09| confirmButton |\x0a\x09\x0a\x09html div \x0a\x09\x09class: 'buttons';\x0a\x09\x09with: [\x0a\x09\x09\x09html button\x0a\x09\x09\x09\x09class: 'button';\x0a\x09\x09\x09\x09with: self cancelButtonLabel;\x0a\x09\x09\x09\x09onClick: [ self cancel ].\x0a\x09\x09\x09confirmButton := html button\x0a\x09\x09\x09\x09class: 'button default';\x0a\x09\x09\x09\x09with: self confirmButtonLabel;\x0a\x09\x09\x09\x09onClick: [ self confirm ] ].\x0a\x0a\x09self giveFocusToButton:confirmButton",
+messageSends: ["class:", "div", "with:", "button", "cancelButtonLabel", "onClick:", "cancel", "confirmButtonLabel", "confirm", "giveFocusToButton:"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderMainOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._span();
+_st($1)._class_("head");
+$2=_st($1)._with_(self._confirmationString());
+return self}, function($ctx1) {$ctx1.fill(self,"renderMainOn:",{html:html},globals.HLConfirmationWidget)})},
+args: ["html"],
+source: "renderMainOn: html\x0a\x09html span \x0a\x09\x09class: 'head'; \x0a\x09\x09with: self confirmationString",
+messageSends: ["class:", "span", "with:", "confirmationString"],
+referencedClasses: []
+}),
+globals.HLConfirmationWidget);
+
+
+
+smalltalk.addClass('HLRequestWidget', globals.HLConfirmationWidget, ['input', 'multiline', 'value'], 'Helios-Core');
+globals.HLRequestWidget.comment="I display a modal window requesting user input.\x0a\x0a## API\x0a\x0a`HLWidget >> #request:do:` and `#request:value:do:` are convenience methods for creating modal request dialogs.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "beMultiline",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+self["@multiline"]=true;
+return self},
+args: [],
+source: "beMultiline\x0a\x09multiline := true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "beSingleline",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+self["@multiline"]=false;
+return self},
+args: [],
+source: "beSingleline\x0a\x09multiline := false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var val;
+return smalltalk.withContext(function($ctx1) { 
+val=_st(_st(self["@input"])._asJQuery())._val();
+self._remove();
+_st(self._actionBlock())._value_(val);
+return self}, function($ctx1) {$ctx1.fill(self,"confirm",{val:val},globals.HLRequestWidget)})},
+args: [],
+source: "confirm\x0a\x09| val |\x0a\x09val := input asJQuery val.\x0a\x09self remove.\x0a\x09self actionBlock value: val",
+messageSends: ["val", "asJQuery", "remove", "value:", "actionBlock"],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "large";
+},
+args: [],
+source: "cssClass\x0a\x09^ 'large'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "giveFocusToButton:",
+protocol: 'private',
+fn: function (aButton){
+var self=this;
+return self},
+args: ["aButton"],
+source: "giveFocusToButton: aButton",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isMultiline",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@multiline"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=true;
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isMultiline",{},globals.HLRequestWidget)})},
+args: [],
+source: "isMultiline\x0a\x09^ multiline ifNil: [ true ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderMainOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5,$6;
+($ctx1.supercall = true, globals.HLRequestWidget.superclass.fn.prototype._renderMainOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+$1=self._isMultiline();
+if(smalltalk.assert($1)){
+self["@input"]=_st(html)._textarea();
+self["@input"];
+} else {
+$2=_st(html)._input();
+_st($2)._type_("text");
+_st($2)._onKeyDown_((function(event){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(_st(event)._keyCode()).__eq((13));
+if(smalltalk.assert($3)){
+return self._confirm();
+};
+}, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1,3)})}));
+$4=_st($2)._yourself();
+self["@input"]=$4;
+self["@input"];
+};
+$5=_st(self["@input"])._asJQuery();
+_st($5)._val_(self._value());
+$6=_st($5)._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"renderMainOn:",{html:html},globals.HLRequestWidget)})},
+args: ["html"],
+source: "renderMainOn: html\x0a\x09super renderMainOn: html.\x0a\x09self isMultiline\x0a\x09\x09ifTrue: [ input := html textarea ]\x0a\x09\x09ifFalse: [ input := html input \x0a\x09\x09\x09type: 'text';\x0a\x09\x09\x09onKeyDown: [ :event |\x0a\x09\x09\x09\x09event keyCode = 13 ifTrue: [\x0a\x09\x09\x09\x09\x09self confirm ] ];\x0a\x09\x09\x09yourself ].\x0a\x09input asJQuery \x0a\x09\x09val: self value;\x0a\x09\x09focus",
+messageSends: ["renderMainOn:", "ifTrue:ifFalse:", "isMultiline", "textarea", "type:", "input", "onKeyDown:", "ifTrue:", "=", "keyCode", "confirm", "yourself", "val:", "asJQuery", "value", "focus"],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "value",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@value"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"value",{},globals.HLRequestWidget)})},
+args: [],
+source: "value\x0a\x09^ value ifNil: [ '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "value:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@value"]=aString;
+return self},
+args: ["aString"],
+source: "value: aString\x0a\x09value := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRequestWidget);
+
+
+
+smalltalk.addClass('HLProgressWidget', globals.HLModalWidget, ['progressBars', 'visible'], 'Helios-Core');
+globals.HLProgressWidget.comment="I am a widget used to display progress modal dialogs.\x0a\x0aMy default instance is accessed with `HLProgressWidget class >> #default`.\x0a\x0aSee `HLProgressHandler` for usage.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addProgressBar:",
+protocol: 'actions',
+fn: function (aProgressBar){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._show();
+_st(self._progressBars())._add_(aProgressBar);
+_st(aProgressBar)._appendToJQuery_(_st(_st(self._wrapper())._asJQuery())._find_(".dialog"));
+return self}, function($ctx1) {$ctx1.fill(self,"addProgressBar:",{aProgressBar:aProgressBar},globals.HLProgressWidget)})},
+args: ["aProgressBar"],
+source: "addProgressBar: aProgressBar\x0a\x09self show.\x0a\x09self progressBars add: aProgressBar.\x0a\x09aProgressBar appendToJQuery: (self wrapper asJQuery find: '.dialog')",
+messageSends: ["show", "add:", "progressBars", "appendToJQuery:", "find:", "asJQuery", "wrapper"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "do:on:displaying:",
+protocol: 'actions',
+fn: function (aBlock,aCollection,aString){
+var self=this;
+var progressBar;
+function $HLProgressBarWidget(){return globals.HLProgressBarWidget||(typeof HLProgressBarWidget=="undefined"?nil:HLProgressBarWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLProgressBarWidget())._new();
+_st($1)._parent_(self);
+_st($1)._label_(aString);
+_st($1)._workBlock_(aBlock);
+_st($1)._collection_(aCollection);
+$2=_st($1)._yourself();
+progressBar=$2;
+self._addProgressBar_(progressBar);
+_st(progressBar)._start();
+return self}, function($ctx1) {$ctx1.fill(self,"do:on:displaying:",{aBlock:aBlock,aCollection:aCollection,aString:aString,progressBar:progressBar},globals.HLProgressWidget)})},
+args: ["aBlock", "aCollection", "aString"],
+source: "do: aBlock on: aCollection displaying: aString\x0a\x09| progressBar |\x0a\x09\x0a\x09progressBar := HLProgressBarWidget new\x0a\x09\x09parent: self;\x0a\x09\x09label: aString;\x0a\x09\x09workBlock: aBlock;\x0a\x09\x09collection: aCollection;\x0a\x09\x09yourself.\x0a\x09\x0a\x09self addProgressBar: progressBar.\x0a\x09progressBar start",
+messageSends: ["parent:", "new", "label:", "workBlock:", "collection:", "yourself", "addProgressBar:", "start"],
+referencedClasses: ["HLProgressBarWidget"]
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "flush",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._progressBars())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return self._removeProgressBar_(each);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"flush",{},globals.HLProgressWidget)})},
+args: [],
+source: "flush\x0a\x09self progressBars do: [ :each |\x0a\x09\x09self removeProgressBar: each ]",
+messageSends: ["do:", "progressBars", "removeProgressBar:"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hasButtons",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "hasButtons\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isVisible",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@visible"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=false;
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isVisible",{},globals.HLProgressWidget)})},
+args: [],
+source: "isVisible\x0a\x09^ visible ifNil: [ false ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "progressBars",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@progressBars"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@progressBars"]=_st($OrderedCollection())._new();
+$1=self["@progressBars"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"progressBars",{},globals.HLProgressWidget)})},
+args: [],
+source: "progressBars\x0a\x09^ progressBars ifNil: [ progressBars := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "remove",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._isVisible();
+if(smalltalk.assert($1)){
+self["@visible"]=false;
+self["@visible"];
+($ctx1.supercall = true, globals.HLProgressWidget.superclass.fn.prototype._remove.apply(_st(self), []));
+$ctx1.supercall = false;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"remove",{},globals.HLProgressWidget)})},
+args: [],
+source: "remove\x0a\x09self isVisible ifTrue: [\x0a\x09\x09visible := false.\x0a\x09\x09super remove ]",
+messageSends: ["ifTrue:", "isVisible", "remove"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeProgressBar:",
+protocol: 'actions',
+fn: function (aProgressBar){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._progressBars();
+$ctx1.sendIdx["progressBars"]=1;
+_st($1)._remove_ifAbsent_(aProgressBar,(function(){
+}));
+_st(_st(_st(aProgressBar)._wrapper())._asJQuery())._remove();
+$ctx1.sendIdx["remove"]=1;
+_st(self._progressBars())._ifEmpty_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._remove();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"removeProgressBar:",{aProgressBar:aProgressBar},globals.HLProgressWidget)})},
+args: ["aProgressBar"],
+source: "removeProgressBar: aProgressBar\x0a\x09self progressBars remove: aProgressBar ifAbsent: [].\x0a\x09aProgressBar wrapper asJQuery remove.\x0a\x09\x0a\x09self progressBars ifEmpty: [ self remove ]",
+messageSends: ["remove:ifAbsent:", "progressBars", "remove", "asJQuery", "wrapper", "ifEmpty:"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderMainOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._progressBars())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(html)._with_(each);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderMainOn:",{html:html},globals.HLProgressWidget)})},
+args: ["html"],
+source: "renderMainOn: html\x0a\x09self progressBars do: [ :each |\x0a\x09\x09html with: each ]",
+messageSends: ["do:", "progressBars", "with:"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._isVisible();
+if(! smalltalk.assert($1)){
+self["@visible"]=true;
+self["@visible"];
+($ctx1.supercall = true, globals.HLProgressWidget.superclass.fn.prototype._show.apply(_st(self), []));
+$ctx1.supercall = false;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"show",{},globals.HLProgressWidget)})},
+args: [],
+source: "show\x0a\x09self isVisible ifFalse: [\x0a\x09\x09visible := true.\x0a\x09\x09super show ]",
+messageSends: ["ifFalse:", "isVisible", "show"],
+referencedClasses: []
+}),
+globals.HLProgressWidget);
+
+
+globals.HLProgressWidget.klass.iVarNames = ['default'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "default",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@default"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@default"]=self._new();
+$1=self["@default"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"default",{},globals.HLProgressWidget.klass)})},
+args: [],
+source: "default\x0a\x09^ default ifNil: [ default := self new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: []
+}),
+globals.HLProgressWidget.klass);
+
+
+smalltalk.addClass('HLTabSelectionWidget', globals.HLModalWidget, ['tabs', 'tabList', 'selectedTab', 'selectCallback', 'cancelCallback', 'confirmCallback'], 'Helios-Core');
+globals.HLTabSelectionWidget.comment="I am a modal window used to select or create tabs.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._remove();
+_st(self._cancelCallback())._value();
+return self}, function($ctx1) {$ctx1.fill(self,"cancel",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "cancel\x0a\x09self remove.\x0a\x09self cancelCallback value",
+messageSends: ["remove", "value", "cancelCallback"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancelCallback",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@cancelCallback"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=(function(){
+});
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cancelCallback",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "cancelCallback\x0a\x09^ cancelCallback ifNil: [ [] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cancelCallback:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@cancelCallback"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "cancelCallback: aBlock\x0a\x09cancelCallback := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirm",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._remove();
+_st(self._confirmCallback())._value_(self._selectedTab());
+return self}, function($ctx1) {$ctx1.fill(self,"confirm",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "confirm\x0a\x09self remove.\x0a\x09self confirmCallback value: self selectedTab",
+messageSends: ["remove", "value:", "confirmCallback", "selectedTab"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmCallback",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@confirmCallback"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=(function(){
+});
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"confirmCallback",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "confirmCallback\x0a\x09^ confirmCallback ifNil: [ [] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmCallback:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@confirmCallback"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "confirmCallback: aBlock\x0a\x09confirmCallback := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+var confirmButton;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$5,$6,$2;
+$1=_st(html)._div();
+_st($1)._class_("buttons");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._button();
+$ctx2.sendIdx["button"]=1;
+_st($3)._class_("button");
+$ctx2.sendIdx["class:"]=2;
+_st($3)._with_("Cancel");
+$ctx2.sendIdx["with:"]=2;
+$4=_st($3)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._cancel();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$ctx2.sendIdx["onClick:"]=1;
+$4;
+$5=_st(html)._button();
+_st($5)._class_("button default");
+_st($5)._with_("Select tab");
+$6=_st($5)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._confirm();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+confirmButton=$6;
+return confirmButton;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+self._giveFocusToButton_(confirmButton);
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html,confirmButton:confirmButton},globals.HLTabSelectionWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09| confirmButton |\x0a\x09\x0a\x09html div \x0a\x09\x09class: 'buttons';\x0a\x09\x09with: [\x0a\x09\x09\x09html button\x0a\x09\x09\x09\x09class: 'button';\x0a\x09\x09\x09\x09with: 'Cancel';\x0a\x09\x09\x09\x09onClick: [ self cancel ].\x0a\x09\x09\x09confirmButton := html button\x0a\x09\x09\x09\x09class: 'button default';\x0a\x09\x09\x09\x09with: 'Select tab';\x0a\x09\x09\x09\x09onClick: [ self confirm ] ].\x0a\x0a\x09self giveFocusToButton:confirmButton",
+messageSends: ["class:", "div", "with:", "button", "onClick:", "cancel", "confirm", "giveFocusToButton:"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLTabSelectionWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+_st(self._tabList())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLTabSelectionWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09super renderContentOn: html.\x0a\x09self tabList focus",
+messageSends: ["renderContentOn:", "focus", "tabList"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderMainOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("title");
+$2=_st($1)._with_("Tab selection");
+$ctx1.sendIdx["with:"]=1;
+_st(html)._with_(self._tabList());
+return self}, function($ctx1) {$ctx1.fill(self,"renderMainOn:",{html:html},globals.HLTabSelectionWidget)})},
+args: ["html"],
+source: "renderMainOn: html\x0a\x09html div \x0a\x09\x09class: 'title'; \x0a\x09\x09with: 'Tab selection'.\x0a\x09\x0a\x09html with: self tabList",
+messageSends: ["class:", "div", "with:", "tabList"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderTab:on:",
+protocol: 'rendering',
+fn: function (aTab,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._span();
+_st($1)._class_(_st(aTab)._cssClass());
+$2=_st($1)._with_(_st(aTab)._label());
+return self}, function($ctx1) {$ctx1.fill(self,"renderTab:on:",{aTab:aTab,html:html},globals.HLTabSelectionWidget)})},
+args: ["aTab", "html"],
+source: "renderTab: aTab on: html\x0a\x09html \x0a\x09\x09span \x0a\x09\x09\x09class: aTab cssClass;\x0a\x09\x09\x09with: aTab label",
+messageSends: ["class:", "span", "cssClass", "with:", "label"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderTabsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st(self._tabs())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(html)._li())._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+$1=_st(html)._a();
+_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx4) {
+return self._renderTab_on_(each,html);
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,3)})}));
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx4) {
+return self._selectTab_(each);
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,4)})}));
+return $2;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$ctx2.sendIdx["with:"]=1;
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderTabsOn:",{html:html},globals.HLTabSelectionWidget)})},
+args: ["html"],
+source: "renderTabsOn: html\x0a\x09self tabs do: [ :each |\x0a\x09\x09html li with: [ \x0a\x09\x09\x09html a \x0a\x09\x09\x09\x09with: [ \x0a\x09\x09\x09\x09\x09self renderTab: each on: html ];\x0a\x09\x09\x09\x09onClick: [ self selectTab: each ] ] ]",
+messageSends: ["do:", "tabs", "with:", "li", "a", "renderTab:on:", "onClick:", "selectTab:"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectCallback",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@selectCallback"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=(function(){
+});
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectCallback",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "selectCallback\x0a\x09^ selectCallback ifNil: [ [] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectCallback:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@selectCallback"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "selectCallback: aBlock\x0a\x09selectCallback := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectTab:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectedTab_(aTab);
+_st(self._selectCallback())._value_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"selectTab:",{aTab:aTab},globals.HLTabSelectionWidget)})},
+args: ["aTab"],
+source: "selectTab: aTab\x0a\x09self selectedTab: aTab.\x0a\x09self selectCallback value: aTab",
+messageSends: ["selectedTab:", "value:", "selectCallback"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedTab",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selectedTab"];
+return $1;
+},
+args: [],
+source: "selectedTab\x0a\x09^ selectedTab",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedTab:",
+protocol: 'accessing',
+fn: function (aTab){
+var self=this;
+self["@selectedTab"]=aTab;
+return self},
+args: ["aTab"],
+source: "selectedTab: aTab\x0a\x09selectedTab := aTab",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupKeyBindings",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+($ctx1.supercall = true, globals.HLTabSelectionWidget.superclass.fn.prototype._setupKeyBindings.apply(_st(self), []));
+$ctx1.supercall = false;
+_st(".dialog"._asJQuery())._keyup_((function(e){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(_st(e)._keyCode()).__eq(_st(_st($String())._cr())._asciiValue());
+if(smalltalk.assert($1)){
+return self._confirm();
+};
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupKeyBindings",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "setupKeyBindings\x0a\x09super setupKeyBindings.\x0a\x09'.dialog' asJQuery keyup: [ :e |\x0a\x09\x09e keyCode = String cr asciiValue ifTrue: [ self confirm ] ]",
+messageSends: ["setupKeyBindings", "keyup:", "asJQuery", "ifTrue:", "=", "keyCode", "asciiValue", "cr", "confirm"],
+referencedClasses: ["String"]
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabList",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+function $HLTabListWidget(){return globals.HLTabListWidget||(typeof HLTabListWidget=="undefined"?nil:HLTabListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$receiver;
+$1=self["@tabList"];
+if(($receiver = $1) == null || $receiver.isNil){
+self["@tabList"]=_st($HLTabListWidget())._new();
+self["@tabList"];
+$2=self["@tabList"];
+_st($2)._callback_((function(tab){
+return smalltalk.withContext(function($ctx2) {
+self._selectTab_(tab);
+return _st(self["@tabList"])._focus();
+}, function($ctx2) {$ctx2.fillBlock({tab:tab},$ctx1,2)})}));
+_st($2)._selectedItem_(self._selectedTab());
+$3=_st($2)._items_(self._tabs());
+$3;
+} else {
+$1;
+};
+$4=self["@tabList"];
+return $4;
+}, function($ctx1) {$ctx1.fill(self,"tabList",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "tabList\x0a\x09tabList ifNil: [ \x0a\x09\x09tabList := HLTabListWidget new.\x0a\x09\x09tabList\x0a\x09\x09\x09callback: [ :tab | self selectTab: tab. tabList focus ];\x0a\x09\x09\x09selectedItem: self selectedTab;\x0a\x09\x09\x09items: self tabs ].\x0a\x09\x0a\x09^ tabList",
+messageSends: ["ifNil:", "new", "callback:", "selectTab:", "focus", "selectedItem:", "selectedTab", "items:", "tabs"],
+referencedClasses: ["HLTabListWidget"]
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabs",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@tabs"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=[];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabs",{},globals.HLTabSelectionWidget)})},
+args: [],
+source: "tabs\x0a\x09^ tabs ifNil: [ #() ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabs:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@tabs"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "tabs: aCollection\x0a\x09tabs := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabSelectionWidget);
+
+
+
+smalltalk.addClass('HLProgressBarWidget', globals.HLWidget, ['label', 'parent', 'workBlock', 'collection', 'bar'], 'Helios-Core');
+globals.HLProgressBarWidget.comment="I am a widget used to display a progress bar while iterating over a collection.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "collection",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@collection"];
+return $1;
+},
+args: [],
+source: "collection\x0a\x09^ collection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "collection:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@collection"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "collection: aCollection\x0a\x09collection := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "evaluateAt:",
+protocol: 'actions',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $4,$3,$2,$1,$7,$6,$5;
+$4=self._collection();
+$ctx1.sendIdx["collection"]=1;
+$3=_st($4)._size();
+$ctx1.sendIdx["size"]=1;
+$2=_st(anInteger).__slash($3);
+$1=_st($2).__star((100));
+self._updateProgress_($1);
+$7=self._collection();
+$ctx1.sendIdx["collection"]=2;
+$6=_st($7)._size();
+$5=_st(anInteger).__lt_eq($6);
+if(smalltalk.assert($5)){
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+_st(self._workBlock())._value_(_st(self._collection())._at_(anInteger));
+return self._evaluateAt_(_st(anInteger).__plus((1)));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}))._valueWithTimeout_((10));
+$ctx1.sendIdx["valueWithTimeout:"]=1;
+} else {
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._remove();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)})}))._valueWithTimeout_((500));
+};
+return self}, function($ctx1) {$ctx1.fill(self,"evaluateAt:",{anInteger:anInteger},globals.HLProgressBarWidget)})},
+args: ["anInteger"],
+source: "evaluateAt: anInteger\x0a\x09self updateProgress: (anInteger / self collection size) * 100.\x0a\x09anInteger <= self collection size\x0a\x09\x09ifTrue: [ \x0a\x09\x09\x09[ \x0a\x09\x09\x09\x09self workBlock value: (self collection at: anInteger).\x0a\x09\x09\x09\x09self evaluateAt: anInteger + 1 ] valueWithTimeout: 10 ]\x0a\x09\x09ifFalse: [ [ self remove ] valueWithTimeout: 500 ]",
+messageSends: ["updateProgress:", "*", "/", "size", "collection", "ifTrue:ifFalse:", "<=", "valueWithTimeout:", "value:", "workBlock", "at:", "evaluateAt:", "+", "remove"],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@label"];
+return $1;
+},
+args: [],
+source: "label\x0a\x09^ label",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@label"]=aString;
+return self},
+args: ["aString"],
+source: "label: aString\x0a\x09label := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "parent",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@parent"];
+return $1;
+},
+args: [],
+source: "parent\x0a\x09^ parent",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "parent:",
+protocol: 'accessing',
+fn: function (aProgress){
+var self=this;
+self["@parent"]=aProgress;
+return self},
+args: ["aProgress"],
+source: "parent: aProgress\x0a\x09parent := aProgress",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "remove",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._parent())._removeProgressBar_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"remove",{},globals.HLProgressBarWidget)})},
+args: [],
+source: "remove\x0a\x09self parent removeProgressBar: self",
+messageSends: ["removeProgressBar:", "parent"],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$2;
+_st(_st(html)._span())._with_(self._label());
+$ctx1.sendIdx["with:"]=1;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._class_("progress");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._div();
+_st($3)._class_("bar");
+$4=_st($3)._style_("width: 0%");
+self["@bar"]=$4;
+return self["@bar"];
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLProgressBarWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html span with: self label.\x0a\x09html div \x0a\x09\x09class: 'progress';\x0a\x09\x09with: [\x0a\x09\x09\x09bar := html div \x0a\x09\x09\x09\x09class: 'bar';\x0a\x09\x09\x09\x09style: 'width: 0%' ]",
+messageSends: ["with:", "span", "label", "class:", "div", "style:"],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "start",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._evaluateAt_((1));
+return self}, function($ctx1) {$ctx1.fill(self,"start",{},globals.HLProgressBarWidget)})},
+args: [],
+source: "start\x0a\x09\x22Make sure the UI has some time to update itself between each iteration\x22\x0a\x09\x0a\x09self evaluateAt: 1",
+messageSends: ["evaluateAt:"],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateProgress:",
+protocol: 'actions',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self["@bar"])._asJQuery())._css_put_("width",_st(_st(anInteger)._asString()).__comma("%"));
+return self}, function($ctx1) {$ctx1.fill(self,"updateProgress:",{anInteger:anInteger},globals.HLProgressBarWidget)})},
+args: ["anInteger"],
+source: "updateProgress: anInteger\x0a\x09bar asJQuery css: 'width' put: anInteger asString, '%'",
+messageSends: ["css:put:", "asJQuery", ",", "asString"],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "workBlock",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@workBlock"];
+return $1;
+},
+args: [],
+source: "workBlock\x0a\x09^ workBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "workBlock:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@workBlock"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "workBlock: aBlock\x0a\x09workBlock := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget);
+
+
+globals.HLProgressBarWidget.klass.iVarNames = ['default'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "default",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@default"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@default"]=self._new();
+$1=self["@default"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"default",{},globals.HLProgressBarWidget.klass)})},
+args: [],
+source: "default\x0a\x09^ default ifNil: [ default := self new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: []
+}),
+globals.HLProgressBarWidget.klass);
+
+
+smalltalk.addClass('HLTabWidget', globals.HLWidget, ['widget', 'label', 'root'], 'Helios-Core');
+globals.HLTabWidget.comment="I am a widget specialized into building another widget as an Helios tab.\x0a\x0aI should not be used directly, `HLWidget class >> #openAsTab` should be used instead.\x0a\x0a## Example\x0a\x0a    HLWorkspace openAsTab";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activate",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._activate_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"activate",{},globals.HLTabWidget)})},
+args: [],
+source: "activate\x0a\x09self manager activate: self",
+messageSends: ["activate:", "manager"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "add",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._manager())._addTab_(self);
+self._observeManager();
+return self}, function($ctx1) {$ctx1.fill(self,"add",{},globals.HLTabWidget)})},
+args: [],
+source: "add\x0a\x09self manager addTab: self.\x0a\x09self observeManager",
+messageSends: ["addTab:", "manager", "observeManager"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._widget())._tabClass();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLTabWidget)})},
+args: [],
+source: "cssClass\x0a\x09^ self widget tabClass",
+messageSends: ["tabClass", "widget"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=self._widget();
+$ctx1.sendIdx["widget"]=1;
+$1=_st($2)._canHaveFocus();
+if(smalltalk.assert($1)){
+_st(self._widget())._focus();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLTabWidget)})},
+args: [],
+source: "focus\x0a\x09self widget canHaveFocus ifTrue: [\x0a\x09\x09self widget focus ]",
+messageSends: ["ifTrue:", "canHaveFocus", "widget", "focus"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hide",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self["@root"];
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+_st(_st(self["@root"])._asJQuery())._css_put_("visibility","hidden");
+};
+return self}, function($ctx1) {$ctx1.fill(self,"hide",{},globals.HLTabWidget)})},
+args: [],
+source: "hide\x0a\x09root ifNotNil: [ root asJQuery css: 'visibility' put: 'hidden' ]",
+messageSends: ["ifNotNil:", "css:put:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._manager())._activeTab()).__eq(self);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLTabWidget)})},
+args: [],
+source: "isActive\x0a\x09^ self manager activeTab = self",
+messageSends: ["=", "activeTab", "manager"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@label"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"label",{},globals.HLTabWidget)})},
+args: [],
+source: "label\x0a\x09^ label ifNil: [ '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@label"]=aString;
+return self},
+args: ["aString"],
+source: "label: aString\x0a\x09label := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "manager",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLManager())._current();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"manager",{},globals.HLTabWidget)})},
+args: [],
+source: "manager\x0a\x09^ HLManager current",
+messageSends: ["current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeManager",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLTabLabelChanged(){return globals.HLTabLabelChanged||(typeof HLTabLabelChanged=="undefined"?nil:HLTabLabelChanged)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._manager())._announcer())._on_send_to_($HLTabLabelChanged(),"onTabLabelChanged:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeManager",{},globals.HLTabWidget)})},
+args: [],
+source: "observeManager\x0a\x09self manager announcer \x0a\x09\x09on: HLTabLabelChanged\x0a\x09\x09send: #onTabLabelChanged:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "manager"],
+referencedClasses: ["HLTabLabelChanged"]
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onTabLabelChanged:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$4,$5,$3;
+$2=_st(anAnnouncement)._widget();
+$ctx1.sendIdx["widget"]=1;
+$1=_st($2).__eq(self._widget());
+$ctx1.sendIdx["="]=1;
+if(smalltalk.assert($1)){
+$4=self._label();
+$ctx1.sendIdx["label"]=1;
+$5=_st(anAnnouncement)._label();
+$ctx1.sendIdx["label"]=2;
+$3=_st($4).__eq($5);
+if(! smalltalk.assert($3)){
+self._label_(_st(anAnnouncement)._label());
+_st(self._manager())._refresh();
+};
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onTabLabelChanged:",{anAnnouncement:anAnnouncement},globals.HLTabWidget)})},
+args: ["anAnnouncement"],
+source: "onTabLabelChanged: anAnnouncement\x0a\x09anAnnouncement widget = self widget ifTrue: [\x0a\x09\x09self label = anAnnouncement label ifFalse: [\x0a\x09\x09\x09self label: anAnnouncement label.\x0a\x09\x09\x09self manager refresh ] ]",
+messageSends: ["ifTrue:", "=", "widget", "ifFalse:", "label", "label:", "refresh", "manager"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerBindings",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._widget())._registerBindings();
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindings",{},globals.HLTabWidget)})},
+args: [],
+source: "registerBindings\x0a\x09self widget registerBindings",
+messageSends: ["registerBindings", "widget"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "remove",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+self._unregister();
+$ctx1.sendIdx["unregister"]=1;
+_st(self._widget())._unregister();
+$1=self["@root"];
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+_st(_st(self["@root"])._asJQuery())._remove();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"remove",{},globals.HLTabWidget)})},
+args: [],
+source: "remove\x0a\x09self unregister.\x0a\x09self widget unregister.\x0a\x09root ifNotNil: [ root asJQuery remove ]",
+messageSends: ["unregister", "widget", "ifNotNil:", "remove", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("tab");
+$2=_st($1)._yourself();
+self["@root"]=$2;
+self._renderTab();
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLTabWidget)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09root := html div\x0a\x09\x09class: 'tab';\x0a\x09\x09yourself.\x0a\x09self renderTab",
+messageSends: ["class:", "div", "yourself", "renderTab"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderTab",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st(self["@root"])._contents_((function(html){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(html)._div();
+_st($1)._class_("amber_box");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._widget())._renderOn_(html);
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+return $2;
+}, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderTab",{},globals.HLTabWidget)})},
+args: [],
+source: "renderTab\x0a\x09root contents: [ :html |\x0a\x09\x09html div\x0a\x09\x09\x09class: 'amber_box';\x0a\x09\x09\x09with: [ self widget renderOn: html ] ]",
+messageSends: ["contents:", "class:", "div", "with:", "renderOn:", "widget"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+$1=self["@root"];
+if(($receiver = $1) == null || $receiver.isNil){
+$2="body"._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+self._appendToJQuery_($2);
+} else {
+_st(_st(self["@root"])._asJQuery())._css_put_("visibility","visible");
+};
+return self}, function($ctx1) {$ctx1.fill(self,"show",{},globals.HLTabWidget)})},
+args: [],
+source: "show\x0a\x09root\x0a\x09\x09ifNil: [ self appendToJQuery: 'body' asJQuery ]\x0a\x09\x09ifNotNil: [ root asJQuery css: 'visibility' put: 'visible' ]",
+messageSends: ["ifNil:ifNotNil:", "appendToJQuery:", "asJQuery", "css:put:"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._manager())._announcer())._unsubscribe_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLTabWidget)})},
+args: [],
+source: "unregister\x0a\x09self manager announcer unsubscribe: self",
+messageSends: ["unsubscribe:", "announcer", "manager"],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "widget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@widget"];
+return $1;
+},
+args: [],
+source: "widget\x0a\x09^ widget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "widget:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+self["@widget"]=aWidget;
+return self},
+args: ["aWidget"],
+source: "widget: aWidget\x0a\x09widget := aWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:labelled:",
+protocol: 'instance creation',
+fn: function (aWidget,aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._widget_(aWidget);
+_st($2)._label_(aString);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:labelled:",{aWidget:aWidget,aString:aString},globals.HLTabWidget.klass)})},
+args: ["aWidget", "aString"],
+source: "on: aWidget labelled: aString\x0a\x09^ self new\x0a\x09\x09widget: aWidget;\x0a\x09\x09label: aString;\x0a\x09\x09yourself",
+messageSends: ["widget:", "new", "label:", "yourself"],
+referencedClasses: []
+}),
+globals.HLTabWidget.klass);
+
+
+smalltalk.addClass('HLTabsWidget', globals.HLWidget, ['tabs', 'activeTab', 'history', 'selectionDisabled'], 'Helios-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activate:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._isSelectionDisabled();
+if(smalltalk.assert($1)){
+return self;
+};
+_st(_st(self._manager())._keyBinder())._flushBindings();
+_st(aTab)._registerBindings();
+self["@activeTab"]=aTab;
+self._refresh();
+self._addToHistory_(aTab);
+$2=self._show_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"activate:",{aTab:aTab},globals.HLTabsWidget)})},
+args: ["aTab"],
+source: "activate: aTab\x0a\x09self isSelectionDisabled ifTrue: [ ^ self ].\x0a\x0a\x09self manager keyBinder flushBindings.\x0a\x09aTab registerBindings.\x0a\x09activeTab := aTab.\x0a\x09\x0a\x09self \x0a\x09\x09refresh;\x0a\x09\x09addToHistory: aTab;\x0a\x09\x09show: aTab",
+messageSends: ["ifTrue:", "isSelectionDisabled", "flushBindings", "keyBinder", "manager", "registerBindings", "refresh", "addToHistory:", "show:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateNextTab",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var nextTab;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$5,$4,$3;
+var $early={};
+try {
+$1=self._tabs();
+$ctx1.sendIdx["tabs"]=1;
+_st($1)._ifEmpty_((function(){
+throw $early=[self];
+}));
+$2=self._tabs();
+$ctx1.sendIdx["tabs"]=2;
+$5=self._tabs();
+$ctx1.sendIdx["tabs"]=3;
+$4=_st($5)._indexOf_(self._activeTab());
+$3=_st($4).__plus((1));
+nextTab=_st($2)._at_ifAbsent_($3,(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._tabs())._first();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+self._activate_(nextTab);
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"activateNextTab",{nextTab:nextTab},globals.HLTabsWidget)})},
+args: [],
+source: "activateNextTab\x0a\x09| nextTab |\x0a\x09\x0a\x09self tabs ifEmpty: [ ^ self ].\x0a\x09\x0a\x09nextTab := self tabs \x0a\x09\x09at: (self tabs indexOf: self activeTab) + 1 \x0a\x09\x09ifAbsent: [ self tabs first ].\x0a\x09\x09\x0a\x09self activate: nextTab",
+messageSends: ["ifEmpty:", "tabs", "at:ifAbsent:", "+", "indexOf:", "activeTab", "first", "activate:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activatePreviousTab",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var previousTab;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$5,$4,$3;
+var $early={};
+try {
+$1=self._tabs();
+$ctx1.sendIdx["tabs"]=1;
+_st($1)._ifEmpty_((function(){
+throw $early=[self];
+}));
+$2=self._tabs();
+$ctx1.sendIdx["tabs"]=2;
+$5=self._tabs();
+$ctx1.sendIdx["tabs"]=3;
+$4=_st($5)._indexOf_(self._activeTab());
+$3=_st($4).__minus((1));
+previousTab=_st($2)._at_ifAbsent_($3,(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._tabs())._last();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+self._activate_(previousTab);
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"activatePreviousTab",{previousTab:previousTab},globals.HLTabsWidget)})},
+args: [],
+source: "activatePreviousTab\x0a\x09| previousTab |\x0a\x09\x0a\x09self tabs ifEmpty: [ ^ self ].\x0a\x09\x0a\x09previousTab := self tabs \x0a\x09\x09at: (self tabs indexOf: self activeTab) - 1 \x0a\x09\x09ifAbsent: [ self tabs last ].\x0a\x09\x09\x0a\x09self activate: previousTab",
+messageSends: ["ifEmpty:", "tabs", "at:ifAbsent:", "-", "indexOf:", "activeTab", "last", "activate:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activeTab",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@activeTab"];
+return $1;
+},
+args: [],
+source: "activeTab\x0a\x09^ activeTab",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addTab:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._tabs())._add_(aTab);
+self._activate_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"addTab:",{aTab:aTab},globals.HLTabsWidget)})},
+args: ["aTab"],
+source: "addTab: aTab\x0a\x09self tabs add: aTab.\x0a    self activate: aTab",
+messageSends: ["add:", "tabs", "activate:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addToHistory:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._removeFromHistory_(aTab);
+_st(self._history())._add_(aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"addToHistory:",{aTab:aTab},globals.HLTabsWidget)})},
+args: ["aTab"],
+source: "addToHistory: aTab\x0a\x09self removeFromHistory: aTab.\x0a\x09self history add: aTab",
+messageSends: ["removeFromHistory:", "add:", "history"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "disableSelection",
+protocol: 'actions',
+fn: function (){
+var self=this;
+self["@selectionDisabled"]=true;
+return self},
+args: [],
+source: "disableSelection\x0a\x09selectionDisabled := true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "enableSelection",
+protocol: 'actions',
+fn: function (){
+var self=this;
+self["@selectionDisabled"]=false;
+return self},
+args: [],
+source: "enableSelection\x0a\x09selectionDisabled := false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "history",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@history"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@history"]=_st($OrderedCollection())._new();
+$1=self["@history"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"history",{},globals.HLTabsWidget)})},
+args: [],
+source: "history\x0a\x09^ history ifNil: [ history := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "history:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@history"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "history: aCollection\x0a\x09history := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isSelectionDisabled",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@selectionDisabled"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=false;
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isSelectionDisabled",{},globals.HLTabsWidget)})},
+args: [],
+source: "isSelectionDisabled\x0a\x09^ selectionDisabled ifNil: [ false ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeActiveTab",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._removeTab_(self._activeTab());
+return self}, function($ctx1) {$ctx1.fill(self,"removeActiveTab",{},globals.HLTabsWidget)})},
+args: [],
+source: "removeActiveTab\x0a\x09self removeTab: self activeTab",
+messageSends: ["removeTab:", "activeTab"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeFromHistory:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._history_(_st(self._history())._reject_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each).__eq_eq(aTab);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})));
+return self}, function($ctx1) {$ctx1.fill(self,"removeFromHistory:",{aTab:aTab},globals.HLTabsWidget)})},
+args: ["aTab"],
+source: "removeFromHistory: aTab\x0a\x09self history: (self history reject: [ :each | each == aTab ])",
+messageSends: ["history:", "reject:", "history", "=="],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeTab:",
+protocol: 'actions',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3;
+$2=self._tabs();
+$ctx1.sendIdx["tabs"]=1;
+$1=_st($2)._includes_(aTab);
+if(! smalltalk.assert($1)){
+return self;
+};
+self._removeFromHistory_(aTab);
+_st(self._tabs())._remove_(aTab);
+_st(_st(self._manager())._keyBinder())._flushBindings();
+_st(aTab)._remove();
+self._refresh();
+$3=self._history();
+$ctx1.sendIdx["history"]=1;
+_st($3)._ifNotEmpty_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(self._history())._last())._activate();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"removeTab:",{aTab:aTab},globals.HLTabsWidget)})},
+args: ["aTab"],
+source: "removeTab: aTab\x0a\x09(self tabs includes: aTab) ifFalse: [ ^ self ].\x0a\x0a\x09self removeFromHistory: aTab.\x0a\x09self tabs remove: aTab.\x0a\x09self manager keyBinder flushBindings.\x0a\x09aTab remove.\x0a\x09self refresh.\x0a\x09self history ifNotEmpty: [\x0a\x09\x09self history last activate ]",
+messageSends: ["ifFalse:", "includes:", "tabs", "removeFromHistory:", "remove:", "flushBindings", "keyBinder", "manager", "remove", "refresh", "ifNotEmpty:", "history", "activate", "last"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "removeTabForWidget:",
+protocol: 'actions',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $early={};
+try {
+self._removeTab_(_st(self._tabs())._detect_ifNone_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._widget()).__eq(aWidget);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){
+throw $early=[self];
+})));
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"removeTabForWidget:",{aWidget:aWidget},globals.HLTabsWidget)})},
+args: ["aWidget"],
+source: "removeTabForWidget: aWidget\x0a\x09self removeTab: (self tabs \x0a\x09\x09detect: [ :each | each widget = aWidget ]\x0a\x09\x09ifNone: [ ^ self ])",
+messageSends: ["removeTab:", "detect:ifNone:", "tabs", "=", "widget"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderAddOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLWidget(){return globals.HLWidget||(typeof HLWidget=="undefined"?nil:HLWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$5,$7,$8,$9,$6,$2;
+$1=_st(html)._div();
+_st($1)._class_("dropdown new_tab");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._a();
+$ctx2.sendIdx["a"]=1;
+_st($3)._class_("dropdown-toggle");
+$ctx2.sendIdx["class:"]=2;
+_st($3)._at_put_("data-toggle","dropdown");
+$4=_st($3)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(html)._tag_("b"))._class_("caret");
+$ctx3.sendIdx["class:"]=3;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$ctx2.sendIdx["with:"]=2;
+$4;
+$5=_st(html)._ul();
+_st($5)._class_("dropdown-menu");
+$6=_st($5)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(_st(_st($HLWidget())._withAllSubclasses())._select_((function(each){
+return smalltalk.withContext(function($ctx4) {
+return _st(each)._canBeOpenAsTab();
+}, function($ctx4) {$ctx4.fillBlock({each:each},$ctx3,4)})})))._sorted_((function(a,b){
+return smalltalk.withContext(function($ctx4) {
+$7=_st(a)._tabPriority();
+$ctx4.sendIdx["tabPriority"]=1;
+return _st($7).__lt(_st(b)._tabPriority());
+}, function($ctx4) {$ctx4.fillBlock({a:a,b:b},$ctx3,5)})})))._do_((function(each){
+return smalltalk.withContext(function($ctx4) {
+return _st(_st(html)._li())._with_((function(){
+return smalltalk.withContext(function($ctx5) {
+$8=_st(html)._a();
+_st($8)._with_(_st(each)._tabLabel());
+$9=_st($8)._onClick_((function(){
+return smalltalk.withContext(function($ctx6) {
+return _st(each)._openAsTab();
+}, function($ctx6) {$ctx6.fillBlock({},$ctx5,8)})}));
+return $9;
+}, function($ctx5) {$ctx5.fillBlock({},$ctx4,7)})}));
+$ctx4.sendIdx["with:"]=4;
+}, function($ctx4) {$ctx4.fillBlock({each:each},$ctx3,6)})}));
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+$ctx2.sendIdx["with:"]=3;
+return $6;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderAddOn:",{html:html},globals.HLTabsWidget)})},
+args: ["html"],
+source: "renderAddOn: html\x0a    html div \x0a    \x09class: 'dropdown new_tab';\x0a        with: [ \x0a\x09\x09\x09html a \x0a        \x09\x09class: 'dropdown-toggle';\x0a           \x09 \x09at: 'data-toggle' put: 'dropdown';\x0a            \x09with: [\x0a  \x09\x09\x09\x09\x09(html tag: 'b') class: 'caret' ].\x0a           html ul \x0a           \x09\x09class: 'dropdown-menu';\x0a                with: [\x0a                  \x09((HLWidget withAllSubclasses\x0a                    \x09select: [ :each | each canBeOpenAsTab ])\x0a                        sorted: [ :a :b | a tabPriority < b tabPriority ])\x0a                        do: [ :each |\x0a  \x09\x09\x09\x09\x09\x09\x09html li with: [\x0a                      \x09\x09\x09html a \x0a                                \x09with: each tabLabel;\x0a      \x09\x09\x09\x09\x09\x09\x09\x09onClick: [ each openAsTab ] ] ] ] ]",
+messageSends: ["class:", "div", "with:", "a", "at:put:", "tag:", "ul", "do:", "sorted:", "select:", "withAllSubclasses", "canBeOpenAsTab", "<", "tabPriority", "li", "tabLabel", "onClick:", "openAsTab"],
+referencedClasses: ["HLWidget"]
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$2;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._class_("navbar navbar-fixed-top");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._div();
+_st($3)._class_("navbar-inner");
+$4=_st($3)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._renderTabsOn_(html);
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+return $4;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+self._renderAddOn_(html);
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLTabsWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html div \x0a\x09\x09class: 'navbar navbar-fixed-top';\x0a\x09\x09with: [ html div \x0a\x09\x09\x09class: 'navbar-inner';\x0a\x09\x09\x09with: [ self renderTabsOn: html ] ].\x0a\x09\x09\x09\x0a\x09self renderAddOn: html",
+messageSends: ["class:", "div", "with:", "renderTabsOn:", "renderAddOn:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderTab:on:",
+protocol: 'rendering',
+fn: function (aTab,html){
+var self=this;
+var li;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$6,$5,$7,$8,$9,$10,$11,$12;
+$1=_st(html)._li();
+$2=$1;
+$3=_st("width: ".__comma(_st(self._tabWidth())._asString())).__comma("px");
+$ctx1.sendIdx[","]=1;
+_st($2)._style_($3);
+$4=$1;
+$6=_st(aTab)._isActive();
+if(smalltalk.assert($6)){
+$5="tab active";
+} else {
+$5="tab inactive";
+};
+_st($4)._class_($5);
+$ctx1.sendIdx["class:"]=1;
+_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(html)._a())._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+$7=_st(_st(html)._tag_("i"))._class_("close");
+$ctx3.sendIdx["class:"]=2;
+_st($7)._onClick_((function(){
+return smalltalk.withContext(function($ctx4) {
+return self._removeTab_(aTab);
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,5)})}));
+$ctx3.sendIdx["onClick:"]=1;
+$8=_st(html)._span();
+_st($8)._class_(_st(aTab)._cssClass());
+$9=$8;
+$10=_st(aTab)._label();
+$ctx3.sendIdx["label"]=1;
+_st($9)._title_($10);
+$11=_st($8)._with_(_st(aTab)._label());
+return $11;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+$ctx2.sendIdx["with:"]=2;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+$ctx1.sendIdx["with:"]=1;
+$12=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(aTab)._activate();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,6)})}));
+li=$12;
+_st(_st(_st(li)._asJQuery())._get_((0)))._at_put_("tab-data",aTab);
+return self}, function($ctx1) {$ctx1.fill(self,"renderTab:on:",{aTab:aTab,html:html,li:li},globals.HLTabsWidget)})},
+args: ["aTab", "html"],
+source: "renderTab: aTab on: html\x0a\x09| li |\x0a\x09li := html li \x0a\x09\x09style: 'width: ', self tabWidth asString, 'px';\x0a\x09\x09class: (aTab isActive ifTrue: [ 'tab active' ] ifFalse: [ 'tab inactive' ]);\x0a\x09\x09with: [\x0a\x09\x09\x09html a\x0a\x09\x09\x09with: [\x0a\x09\x09\x09\x09((html tag: 'i') class: 'close')\x0a\x09\x09\x09\x09\x09onClick: [ self removeTab: aTab ].\x0a\x09\x09\x09\x09html span \x0a\x09\x09\x09\x09\x09class: aTab cssClass;\x0a\x09\x09\x09\x09\x09title: aTab label;\x0a\x09\x09\x09\x09\x09with: aTab label ] ];\x0a\x09\x09onClick: [ aTab activate ].\x0a\x09\x0a\x09(li asJQuery get: 0) at: 'tab-data' put: aTab",
+messageSends: ["style:", "li", ",", "asString", "tabWidth", "class:", "ifTrue:ifFalse:", "isActive", "with:", "a", "onClick:", "tag:", "removeTab:", "span", "cssClass", "title:", "label", "activate", "at:put:", "get:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderTabsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+var ul;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._ul();
+_st($1)._class_("nav main-tabs");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._tabs())._do_((function(each){
+return smalltalk.withContext(function($ctx3) {
+return self._renderTab_on_(each,html);
+}, function($ctx3) {$ctx3.fillBlock({each:each},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+ul=$2;
+_st(_st(ul)._asJQuery())._sortable_(globals.HashedCollection._newFromPairs_(["containment","parent","start",(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._disableSelection();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}),"stop",(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._enableSelection();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,5)})}))._valueWithTimeout_((300));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)})}),"update",(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._updateTabsOrder();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,6)})})]));
+return self}, function($ctx1) {$ctx1.fill(self,"renderTabsOn:",{html:html,ul:ul},globals.HLTabsWidget)})},
+args: ["html"],
+source: "renderTabsOn: html\x0a\x09| ul |\x0a\x09ul := html ul \x0a\x09\x09class: 'nav main-tabs';\x0a\x09\x09with: [ \x0a        \x09self tabs do: [ :each |\x0a\x09\x09\x09\x09self renderTab: each on: html ] ].\x0a\x09\x09\x0a\x09ul asJQuery sortable: #{\x0a\x09\x09'containment' -> 'parent'.\x0a\x09\x09'start' -> [ self disableSelection ].\x0a\x09\x09'stop' -> [ [ self enableSelection] valueWithTimeout: 300 ].\x0a\x09\x09'update' -> [ self updateTabsOrder ]\x0a\x09}",
+messageSends: ["class:", "ul", "with:", "do:", "tabs", "renderTab:on:", "sortable:", "asJQuery", "disableSelection", "valueWithTimeout:", "enableSelection", "updateTabsOrder"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupEvents",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1,$4;
+_st("body"._asJQuery())._keydown_((function(event){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(event)._ctrlKey();
+$ctx2.sendIdx["ctrlKey"]=1;
+$1=_st($2)._and_((function(){
+return smalltalk.withContext(function($ctx3) {
+$3=_st(event)._which();
+$ctx3.sendIdx["which"]=1;
+return _st($3).__eq((188));
+$ctx3.sendIdx["="]=1;
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$ctx2.sendIdx["and:"]=1;
+if(smalltalk.assert($1)){
+self._activatePreviousTab();
+_st(event)._preventDefault();
+$ctx2.sendIdx["preventDefault"]=1;
+};
+$4=_st(_st(event)._ctrlKey())._and_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(event)._which()).__eq((190));
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+if(smalltalk.assert($4)){
+self._activateNextTab();
+return _st(event)._preventDefault();
+};
+}, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupEvents",{},globals.HLTabsWidget)})},
+args: [],
+source: "setupEvents\x0a\x09'body' asJQuery keydown: [ :event |\x0a\x09\x0a\x09\x09\x22ctrl+> and ctrl+<\x22\x0a\x09\x09(event ctrlKey and: [ event which = 188 ]) ifTrue: [\x0a\x09\x09\x09self activatePreviousTab.\x0a\x09\x09\x09event preventDefault ].\x0a\x09\x09(event ctrlKey and: [ event which = 190 ]) ifTrue: [\x0a\x09\x09\x09self activateNextTab.\x0a\x09\x09\x09event preventDefault ] ]",
+messageSends: ["keydown:", "asJQuery", "ifTrue:", "and:", "ctrlKey", "=", "which", "activatePreviousTab", "preventDefault", "activateNextTab"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show:",
+protocol: 'rendering',
+fn: function (aTab){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(self._tabs())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._hide();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+_st(aTab)._show();
+$1=_st(aTab)._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"show:",{aTab:aTab},globals.HLTabsWidget)})},
+args: ["aTab"],
+source: "show: aTab\x0a\x09self tabs do: [ :each | each hide ].\x0a\x09aTab show; focus",
+messageSends: ["do:", "tabs", "hide", "show", "focus"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabWidth",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(_st(window)._asJQuery())._width()).__minus((90))).__slash(_st(self._tabs())._size());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabWidth",{},globals.HLTabsWidget)})},
+args: [],
+source: "tabWidth\x0a\x09^ (window asJQuery width - 90) / self tabs size",
+messageSends: ["/", "-", "width", "asJQuery", "size", "tabs"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabs",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@tabs"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@tabs"]=_st($OrderedCollection())._new();
+$1=self["@tabs"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"tabs",{},globals.HLTabsWidget)})},
+args: [],
+source: "tabs\x0a\x09^ tabs ifNil: [ tabs := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLTabsWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateTabsOrder",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@tabs"]=_st(_st(".main-tabs li"._asJQuery())._toArray())._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._at_("tab-data");
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"updateTabsOrder",{},globals.HLTabsWidget)})},
+args: [],
+source: "updateTabsOrder\x0a\x09tabs := '.main-tabs li' asJQuery toArray \x0a\x09\x09collect: [ :each | each at: 'tab-data' ]",
+messageSends: ["collect:", "toArray", "asJQuery", "at:"],
+referencedClasses: []
+}),
+globals.HLTabsWidget);
+
+
+globals.HLTabsWidget.klass.iVarNames = ['current'];
+
+smalltalk.addClass('HLWelcomeWidget', globals.HLWidget, [], 'Helios-Core');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "welcome";
+},
+args: [],
+source: "cssClass\x0a\x09^ 'welcome'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openClassBrowser",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLBrowser())._openAsTab();
+return self}, function($ctx1) {$ctx1.fill(self,"openClassBrowser",{},globals.HLWelcomeWidget)})},
+args: [],
+source: "openClassBrowser\x0a\x09HLBrowser openAsTab",
+messageSends: ["openAsTab"],
+referencedClasses: ["HLBrowser"]
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openHelp",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "openHelp",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openTestRunner",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "openTestRunner",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openWorkspace",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLWorkspace(){return globals.HLWorkspace||(typeof HLWorkspace=="undefined"?nil:HLWorkspace)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLWorkspace())._openAsTab();
+return self}, function($ctx1) {$ctx1.fill(self,"openWorkspace",{},globals.HLWelcomeWidget)})},
+args: [],
+source: "openWorkspace\x0a\x09HLWorkspace openAsTab",
+messageSends: ["openAsTab"],
+referencedClasses: ["HLWorkspace"]
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4;
+$1=_st(html)._button();
+$ctx1.sendIdx["button"]=1;
+_st($1)._class_("button");
+$ctx1.sendIdx["class:"]=1;
+_st($1)._with_("Class Browser");
+$ctx1.sendIdx["with:"]=1;
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._openClassBrowser();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["onClick:"]=1;
+$3=_st(html)._button();
+_st($3)._class_("button");
+_st($3)._with_("Workspace");
+$4=_st($3)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._openWorkspace();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},globals.HLWelcomeWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09html button\x0a\x09\x09class: 'button';\x0a\x09\x09with: 'Class Browser';\x0a\x09\x09onClick: [ self openClassBrowser ].\x0a\x09html button\x0a\x09\x09class: 'button';\x0a\x09\x09with: 'Workspace';\x0a\x09\x09onClick: [ self openWorkspace ].\x0a\x09\x22html button\x0a\x09\x09class: 'button';\x0a\x09\x09with: 'Test Runner';\x0a\x09\x09onClick: [ self openTestRunner ].\x0a\x09html button\x0a\x09\x09class: 'button';\x0a\x09\x09with: 'Help';\x0a\x09\x09onClick: [ self openHelp ]\x22",
+messageSends: ["class:", "button", "with:", "onClick:", "openClassBrowser", "openWorkspace"],
+referencedClasses: []
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._renderHelpOn_(html);
+$1=self._renderButtonsOn_(html);
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLWelcomeWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09self\x0a\x09\x09renderHelpOn: html;\x0a\x09\x09renderButtonsOn: html",
+messageSends: ["renderHelpOn:", "renderButtonsOn:"],
+referencedClasses: []
+}),
+globals.HLWelcomeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderHelpOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(_st(html)._h2())._with_("No tools are open");
+$ctx1.sendIdx["with:"]=1;
+_st(_st(html)._ul())._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(html)._li();
+$ctx2.sendIdx["li"]=1;
+_st($1)._with_("Perform actions with  ctrl + space");
+$ctx2.sendIdx["with:"]=3;
+return _st(_st(html)._li())._with_("Open one of the common tools:");
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=2;
+return self}, function($ctx1) {$ctx1.fill(self,"renderHelpOn:",{html:html},globals.HLWelcomeWidget)})},
+args: ["html"],
+source: "renderHelpOn: html\x0a\x09html h2 with: 'No tools are open'.\x0a\x09html ul with: [\x0a\x09\x09html li with: 'Perform actions with  ctrl + space'.\x0a\x09\x09html li with: 'Open one of the common tools:' ]",
+messageSends: ["with:", "h2", "ul", "li"],
+referencedClasses: []
+}),
+globals.HLWelcomeWidget);
+
+
+});

src/Helios-Core.st

@@ -0,0 +1,2336 @@
+Smalltalk createPackage: 'Helios-Core'!
+InterfacingObject subclass: #HLModel
+	instanceVariableNames: 'announcer environment'
+	package: 'Helios-Core'!
+!HLModel commentStamp!
+I am the abstract superclass of all models of Helios.
+I am the "Model" part of the MVC pattern implementation in Helios.
+
+I provide access to an `Environment` object and both a local (model-specific) and global (system-specific) announcer.
+
+The `#withChangesDo:` method is handy for performing model changes ensuring that all widgets are aware of the change and can prevent it from happening.
+
+Modifications of the system should be done via commands (see `HLCommand` and subclasses).!
+
+!HLModel methodsFor: 'accessing'!
+
+announcer
+	^ announcer ifNil: [ announcer := Announcer new ]
+!
+
+environment
+	^ environment ifNil: [ self manager environment ]
+!
+
+environment: anEnvironment
+	environment := anEnvironment
+!
+
+manager
+	^ HLManager current
+!
+
+systemAnnouncer
+	^ self environment systemAnnouncer
+! !
+
+!HLModel methodsFor: 'error handling'!
+
+withChangesDo: aBlock
+	[ 
+		self announcer announce: (HLAboutToChange new
+			actionBlock: aBlock;
+			yourself).
+		aBlock value.
+	]
+		on: HLChangeForbidden 
+		do: [ :ex | ]
+! !
+
+!HLModel methodsFor: 'testing'!
+
+isBrowserModel
+	^ false
+!
+
+isReferencesModel
+	^ false
+!
+
+isToolModel
+	^ false
+! !
+
+HLModel subclass: #HLFinder
+	instanceVariableNames: ''
+	package: 'Helios-Core'!
+!HLFinder commentStamp!
+I am the `Finder` service handler of Helios.
+
+Finding a class will open a new class browser, while finding a method will open a references browser.!
+
+!HLFinder methodsFor: 'finding'!
+
+findClass: aClass
+	HLBrowser openAsTab openClassNamed: aClass name
+!
+
+findMethod: aCompiledMethod
+	HLBrowser openAsTab openMethod: aCompiledMethod
+!
+
+findString: aString
+	| foundClass |
+	
+	foundClass := self environment classes 
+		detect: [ :each | each name = aString ]
+		ifNone: [ nil ].
+	
+	foundClass 
+		ifNil: [ HLReferences openAsTab search: aString ]
+		ifNotNil: [ self findClass: foundClass ]
+! !
+
+HLModel subclass: #HLToolModel
+	instanceVariableNames: 'selectedClass selectedPackage selectedProtocol selectedSelector'
+	package: 'Helios-Core'!
+!HLToolModel commentStamp!
+I am a model specific to package and class manipulation. All browsers should either use me or a subclass as their model.
+
+I provide methods for package, class, protocol and method manipulation and access, forwarding to my environment.
+
+I also handle compilation of classes and methods as well as compilation and parsing errors.!
+
+!HLToolModel methodsFor: 'accessing'!
+
+allSelectors
+	^ self environment allSelectors
+!
+
+availableClassNames
+	^ self environment availableClassNames
+!
+
+availablePackageNames
+	^ self environment availablePackageNames
+!
+
+availablePackages
+	^ self environment availablePackageNames
+!
+
+availableProtocols
+	^ self environment availableProtocolsFor: self selectedClass
+!
+
+forceSelectedClass: aClass
+	self withChangesDo: [
+		self 	
+			selectedClass: nil;
+			selectedClass: aClass ]
+!
+
+forceSelectedMethod: aMethod
+	self withChangesDo: [
+		self 	
+			selectedMethod: nil;
+			selectedMethod: aMethod ]
+!
+
+forceSelectedPackage: aPackage
+	self withChangesDo: [
+		self 	
+			selectedPackage: nil;
+			selectedPackage: aPackage ]
+!
+
+forceSelectedProtocol: aProtocol
+	self withChangesDo: [
+		self 	
+			selectedProtocol: nil;
+			selectedProtocol: aProtocol ]
+!
+
+packageToCommit
+	"Answer the package to commit depending on the context:
+	- if a Method is selected, answer its package
+	- else answer the `selectedPackage`"
+	
+	^ self selectedMethod 
+		ifNil: [ self selectedPackage ]
+		ifNotNil: [ :method | method package ]
+!
+
+packages
+	^ self environment packages
+!
+
+selectedClass
+	^ selectedClass
+!
+
+selectedClass: aClass
+	(self selectedClass = aClass and: [ aClass isNil ]) 
+		ifTrue: [ ^ self ].
+	
+	self withChangesDo: [
+		selectedClass = aClass ifTrue: [ 
+			self selectedProtocol: nil ].
+    
+		aClass 
+   			ifNil: [ selectedClass := nil ]
+    		ifNotNil: [
+				self selectedPackage: aClass theNonMetaClass package.
+				self showInstance 
+   					ifTrue: [ selectedClass := aClass theNonMetaClass ]
+     				ifFalse: [ selectedClass := aClass theMetaClass ] ].
+		self selectedProtocol: nil.
+		self announcer announce: (HLClassSelected on: self selectedClass) ]
+!
+
+selectedMethod
+	^ self selectedClass ifNotNil: [ 
+		self selectedClass methodDictionary 
+			at: selectedSelector 
+			ifAbsent: [ nil ] ]
+!
+
+selectedMethod: aCompiledMethod
+	selectedSelector = aCompiledMethod ifTrue: [ ^ self ].
+    
+    self withChangesDo: [
+		aCompiledMethod
+    		ifNil: [ selectedSelector := nil ]
+      		ifNotNil: [
+				selectedClass := aCompiledMethod methodClass.
+				selectedPackage := selectedClass theNonMetaClass package.
+				selectedSelector := aCompiledMethod selector ].
+
+		self announcer announce: (HLMethodSelected on: aCompiledMethod) ]
+!
+
+selectedPackage
+	^ selectedPackage
+!
+
+selectedPackage: aPackage
+	selectedPackage = aPackage ifTrue: [ ^ self ].
+    
+	self withChangesDo: [
+		selectedPackage := aPackage.
+		self selectedClass: nil.
+		self announcer announce: (HLPackageSelected on: aPackage) ]
+!
+
+selectedProtocol
+	^ selectedProtocol
+!
+
+selectedProtocol: aString
+	selectedProtocol = aString ifTrue: [ ^ self ].
+
+	self withChangesDo: [
+		selectedProtocol := aString.
+		self selectedMethod: nil.
+		self announcer announce: (HLProtocolSelected on: aString) ]
+! !
+
+!HLToolModel methodsFor: 'actions'!
+
+addInstVarNamed: aString
+	self environment addInstVarNamed: aString to: self selectedClass.
+	self announcer announce: (HLInstVarAdded new
+		theClass: self selectedClass;
+		variableName: aString;
+		yourself)
+!
+
+save: aString
+	self announcer announce: HLSourceCodeSaved new.
+	
+	(self shouldCompileClassDefinition: aString)
+		ifTrue: [ self compileClassDefinition: aString ]
+		ifFalse: [ self compileMethod: aString ]
+!
+
+saveSourceCode
+	self announcer announce: HLSaveSourceCode new
+! !
+
+!HLToolModel methodsFor: 'commands actions'!
+
+commitPackageOnSuccess: aBlock onError: anotherBlock
+	self environment 
+		commitPackage: self packageToCommit
+		onSuccess: aBlock
+		onError: anotherBlock
+!
+
+copyClassTo: aClassName
+	self withChangesDo: [ 
+		self environment 
+			copyClass: self selectedClass theNonMetaClass
+			to: aClassName ]
+!
+
+moveClassToPackage: aPackageName
+	self withChangesDo: [
+		self environment 
+			moveClass: self selectedClass theNonMetaClass
+			toPackage: aPackageName ]
+!
+
+moveMethodToClass: aClassName
+	self withChangesDo: [
+		self environment 
+			moveMethod: self selectedMethod 
+			toClass: aClassName ]
+!
+
+moveMethodToProtocol: aProtocol
+	self withChangesDo: [
+		self environment 
+			moveMethod: self selectedMethod 
+			toProtocol: aProtocol ]
+!
+
+openClassNamed: aString
+	| class |
+	
+	self withChangesDo: [
+		class := self environment classNamed: aString.
+		self selectedPackage: class package.
+		self selectedClass: class ]
+!
+
+removeClass
+	self withChangesDo: [
+		self manager 
+			confirm: 'Do you REALLY want to remove class ', self selectedClass theNonMetaClass name
+			ifTrue: [ self environment removeClass: self selectedClass theNonMetaClass ] ]
+!
+
+removeMethod
+	self withChangesDo: [
+		self manager 
+			confirm: 'Do you REALLY want to remove method ', self selectedMethod methodClass name,' >> #', self selectedMethod selector
+			ifTrue: [ self environment removeMethod: self selectedMethod ] ]
+!
+
+removeProtocol
+	self withChangesDo: [
+		self manager 
+			confirm: 'Do you REALLY want to remove protocol ', self selectedProtocol
+			ifTrue: [ self environment 
+				removeProtocol: self selectedProtocol 
+				from: self selectedClass ] ]
+!
+
+renameClassTo: aClassName
+	self withChangesDo: [
+		self environment 
+			renameClass: self selectedClass theNonMetaClass
+			to: aClassName ]
+!
+
+renameProtocolTo: aString
+	self withChangesDo: [
+		self environment 
+			renameProtocol: self selectedProtocol
+			to: aString
+			in: self selectedClass ]
+! !
+
+!HLToolModel methodsFor: 'compiling'!
+
+compileClassComment: aString
+	self environment 
+		compileClassComment: aString 
+		for: self selectedClass
+!
+
+compileClassDefinition: aString
+	self environment compileClassDefinition: aString
+!
+
+compileMethod: aString
+	| method |
+	
+	self withCompileErrorHandling: [ 
+		method := self environment 
+			compileMethod: aString 
+			for: self selectedClass
+			protocol: self compilationProtocol.
+
+		self selectedMethod: method ]
+! !
+
+!HLToolModel methodsFor: 'defaults'!
+
+allProtocol
+	^ '-- all --'
+!
+
+unclassifiedProtocol
+	^ 'as yet unclassified'
+! !
+
+!HLToolModel methodsFor: 'error handling'!
+
+handleCompileError: anError
+	self announcer announce: (HLCompileErrorRaised new
+		error: anError;
+		yourself)
+!
+
+handleParseError: anError
+	| split line column messageToInsert |
+	
+	split := anError messageText tokenize: ' : '.
+	messageToInsert := split second.
+
+	"21 = 'Parse error on line ' size + 1"
+	split := split first copyFrom: 21 to: split first size.
+	
+	split := split tokenize: ' column '.
+	line := split first.
+	column := split second.
+	
+	self announcer announce: (HLParseErrorRaised new
+		line: line asNumber;
+		column: column asNumber;
+		message: messageToInsert;
+		error: anError;
+		yourself)
+!
+
+handleUnkownVariableError: anError
+	self announcer announce: (HLUnknownVariableErrorRaised new
+		error: anError;
+		yourself)
+!
+
+withCompileErrorHandling: aBlock
+	self environment
+		evaluate: [
+			self environment 
+			evaluate: [
+				self environment 
+					evaluate: aBlock
+					on: ParseError
+					do: [ :ex | self handleParseError: ex ] ]
+			on: UnknownVariableError
+			do: [ :ex | self handleUnkownVariableError: ex ] ]
+		on: CompilerError
+		do: [ :ex | self handleCompileError: ex ]
+! !
+
+!HLToolModel methodsFor: 'private'!
+
+compilationProtocol
+	| currentProtocol |
+	
+	currentProtocol := self selectedProtocol.
+	currentProtocol ifNil: [ currentProtocol := self unclassifiedProtocol ].
+	self selectedMethod ifNotNil: [ currentProtocol := self selectedMethod protocol ].
+
+	^ currentProtocol = self allProtocol
+		ifTrue: [ self unclassifiedProtocol ]
+		ifFalse: [ currentProtocol ]
+!
+
+withHelperLabelled: aString do: aBlock
+	"TODO: doesn't belong here"
+
+	'#helper' asJQuery remove.
+
+	[ :html |
+		html div 
+			id: 'helper';
+			with: aString ] appendToJQuery: 'body' asJQuery.
+	
+	[
+		aBlock value.
+		'#helper' asJQuery remove
+	] 
+		valueWithTimeout: 10
+! !
+
+!HLToolModel methodsFor: 'testing'!
+
+isToolModel
+	^ true
+!
+
+shouldCompileClassDefinition: aString
+	^ self selectedClass isNil or: [
+		aString match: '^\s*[A-Z]' ]
+! !
+
+!HLToolModel class methodsFor: 'actions'!
+
+on: anEnvironment
+
+	^ self new
+    	environment: anEnvironment;
+        yourself
+! !
+
+Object subclass: #HLProgressHandler
+	instanceVariableNames: ''
+	package: 'Helios-Core'!
+!HLProgressHandler commentStamp!
+I am a specific progress handler for Helios, displaying progresses in a modal window.!
+
+!HLProgressHandler methodsFor: 'progress handling'!
+
+do: aBlock on: aCollection displaying: aString
+	HLProgressWidget default
+		do: aBlock 
+		on: aCollection 
+		displaying: aString
+! !
+
+Widget subclass: #HLWidget
+	instanceVariableNames: 'wrapper'
+	package: 'Helios-Core'!
+!HLWidget commentStamp!
+I am the abstract superclass of all Helios widgets.
+
+I provide common methods, additional behavior to widgets useful for Helios, like dialog creation, command execution and tab creation.
+
+## API
+
+1. Rendering
+
+    Instead of overriding `#renderOn:` as with other Widget subclasses, my subclasses should override `#renderContentOn:`.
+
+2. Refreshing
+
+    To re-render a widget, use `#refresh`.
+
+3. Key bindings registration and tabs
+
+    When displayed as a tab, the widget has a chance to register keybindings with the `#registerBindingsOn:` hook method.
+    
+4. Unregistration
+
+    When a widget has subscribed to announcements or other actions that need to be cleared when closing the tab, the hook method `#unregister` will be called by helios.
+
+5. Tabs
+
+   To enable a widget class to be open as a tab, override the class-side `#canBeOpenAsTab` method to answer `true`. `#tabClass` and `#tabPriority` can be overridden too to respectively change the css class of the tab and the order of tabs in the main menu.
+
+6. Command execution
+
+    An helios command (instance of `HLCommand` or one of its subclass) can be executed with `#execute:`.!
+
+!HLWidget methodsFor: 'accessing'!
+
+cssClass
+	^ 'hl_widget'
+!
+
+manager
+	^ HLManager current
+!
+
+removeTab
+	self manager removeTabForWidget: self
+!
+
+setTabLabel: aString
+	self manager announcer announce: (HLTabLabelChanged new
+		widget: self;
+		label: aString;
+		yourself)
+!
+
+tabClass
+	^ self class tabClass
+!
+
+wrapper
+	^ wrapper
+! !
+
+!HLWidget methodsFor: 'actions'!
+
+confirm: aString ifTrue: aBlock
+	self manager confirm: aString ifTrue: aBlock
+!
+
+confirm: aString ifTrue: aBlock ifFalse: anotherBlock
+	self manager 
+		confirm: aString 
+		ifTrue: aBlock
+		ifFalse: anotherBlock
+!
+
+execute: aCommand
+	HLManager current keyBinder
+		activate;
+		applyBinding: aCommand asBinding
+!
+
+inform: aString
+	self manager inform: aString
+!
+
+openAsTab
+	(HLTabWidget on: self labelled: self defaultTabLabel)
+		add
+!
+
+request: aString do: aBlock
+	self manager request: aString do: aBlock
+!
+
+request: aString value: valueString do: aBlock
+	self manager 
+		request: aString 
+		value: valueString
+		do: aBlock
+!
+
+unregister
+	"This method is called whenever the receiver is closed (as a tab).
+	Widgets subscribing to announcements should unregister there"
+! !
+
+!HLWidget methodsFor: 'defaults'!
+
+defaultTabLabel
+	^ self class tabLabel
+! !
+
+!HLWidget methodsFor: 'keybindings'!
+
+bindKeyDown: keyDownBlock keyUp: keyUpBlock
+	self wrapper asJQuery
+		keydown: keyDownBlock;
+		keyup: keyUpBlock
+!
+
+registerBindings
+	self registerBindingsOn: self manager keyBinder bindings
+!
+
+registerBindingsOn: aBindingGroup
+!
+
+unbindKeyDownKeyUp
+	self wrapper asJQuery
+		unbind: 'keydown';
+		unbind: 'keyup'
+! !
+
+!HLWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+!
+
+renderOn: html
+	wrapper := html div
+		class: self cssClass;
+		yourself.
+    [ :renderer | self renderContentOn: renderer ] appendToJQuery: wrapper asJQuery
+! !
+
+!HLWidget methodsFor: 'testing'!
+
+canHaveFocus
+	^ false
+! !
+
+!HLWidget methodsFor: 'updating'!
+
+refresh
+	self wrapper ifNil: [ ^ self ].
+    
+	self wrapper asJQuery empty.
+    [ :html | self renderContentOn: html ] appendToJQuery: self wrapper asJQuery
+! !
+
+!HLWidget class methodsFor: 'accessing'!
+
+openAsTab
+	| instance |
+	
+	instance := self new.
+	(HLTabWidget 
+		on: instance 
+		labelled: instance defaultTabLabel) add.
+	^ instance
+!
+
+tabClass
+	^ ''
+!
+
+tabLabel
+	^ 'Tab'
+!
+
+tabPriority
+	^ 500
+! !
+
+!HLWidget class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ false
+! !
+
+HLWidget subclass: #HLFocusableWidget
+	instanceVariableNames: ''
+	package: 'Helios-Core'!
+!HLFocusableWidget commentStamp!
+I am a widget that can be focused.
+
+## API 
+
+Instead of overriding `#renderOn:` as with other `Widget` subclasses, my subclasses should override `#renderContentOn:`.
+
+To bring the focus to the widget, use the `#focus` method.!
+
+!HLFocusableWidget methodsFor: 'accessing'!
+
+focusClass
+	^ 'focused'
+! !
+
+!HLFocusableWidget methodsFor: 'events'!
+
+blur
+	self wrapper asJQuery blur
+!
+
+focus
+	self wrapper asJQuery focus
+! !
+
+!HLFocusableWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+!
+
+renderOn: html
+    wrapper := html div 
+    	class: self cssClass;
+		yourself.
+		
+       wrapper with: [ self renderContentOn: html ].
+	
+	wrapper
+		at: 'tabindex' put: '0';
+		onBlur: [ self wrapper asJQuery removeClass: self focusClass ];
+        onFocus: [ self wrapper asJQuery addClass: self focusClass ]
+! !
+
+!HLFocusableWidget methodsFor: 'testing'!
+
+canHaveFocus
+	^ true
+!
+
+hasFocus
+	^ self wrapper notNil and: [ self wrapper asJQuery hasClass: self focusClass ]
+! !
+
+HLFocusableWidget subclass: #HLListWidget
+	instanceVariableNames: 'items selectedItem'
+	package: 'Helios-Core'!
+
+!HLListWidget methodsFor: 'accessing'!
+
+cssClassForItem: anObject
+	^ ''
+!
+
+findListItemFor: anObject
+	^ (((wrapper asJQuery find: 'li') 
+		filter: [ :thisArg :otherArg | (thisArg asJQuery data: 'item') = anObject ] currySelf) eq: 0)
+!
+
+items
+	^ items ifNil: [ items := self defaultItems ]
+!
+
+items: aCollection
+	items := aCollection
+!
+
+listCssClassForItem: anObject
+	^ self selectedItem = anObject
+		ifTrue: [ 'active' ]
+		ifFalse: [ 'inactive' ]
+!
+
+positionOf: aListItem
+	<
+    	return aListItem.parent().children().get().indexOf(aListItem.get(0)) + 1
+	>
+!
+
+selectedItem
+	^ selectedItem
+!
+
+selectedItem: anObject
+	selectedItem := anObject
+! !
+
+!HLListWidget methodsFor: 'actions'!
+
+activateFirstListItem
+	self activateListItem: ((wrapper asJQuery find: 'li.inactive') eq: 0)
+!
+
+activateItem: anObject
+	self activateListItem: (self findListItemFor: anObject)
+!
+
+activateListItem: aListItem
+	| item |
+	
+	(aListItem get: 0) ifNil: [ ^ self ].
+	aListItem parent children removeClass: 'active'.
+	aListItem addClass: 'active'.
+    
+	self ensureVisible: aListItem.
+    
+   "Activate the corresponding item"
+   item := aListItem data: 'item'.
+   self selectedItem == item ifFalse: [
+	   self selectItem: item ]
+!
+
+activateNextListItem
+	self activateListItem: (self wrapper asJQuery find: 'li.active') next.
+	
+	"select the first item if none is selected"
+	(self wrapper asJQuery find: ' .active') get ifEmpty: [
+		self activateFirstListItem ]
+!
+
+activatePreviousListItem
+	self activateListItem: (self wrapper asJQuery find: 'li.active') prev
+!
+
+ensureVisible: aListItem	
+	"Move the scrollbar to show the active element"
+	
+	| parent position |
+	(aListItem get: 0) ifNil: [ ^ self ].
+	position := self positionOf: aListItem.
+	parent := aListItem parent.
+	
+    aListItem position top < 0 ifTrue: [
+		(parent get: 0) scrollTop: ((parent get: 0) scrollTop + aListItem position top - 10) ].
+    aListItem position top + aListItem height > parent height ifTrue: [ 
+		(parent get: 0) scrollTop: ((parent get: 0) scrollTop + aListItem height - (parent height - aListItem position top)) +10 ]
+!
+
+focus
+	super focus.
+    self items isEmpty ifFalse: [ 
+		self selectedItem ifNil: [ self activateFirstListItem ] ]
+!
+
+reactivateListItem: aListItem
+	self activateListItem: aListItem.
+	self reselectItem: self selectedItem
+!
+
+refresh
+	super refresh.
+	self selectedItem ifNotNil: [self ensureVisible: (self findListItemFor: self selectedItem)].
+!
+
+reselectItem: anObject
+!
+
+selectItem: anObject
+	self selectedItem: anObject
+! !
+
+!HLListWidget methodsFor: 'defaults'!
+
+defaultItems
+	^ #()
+! !
+
+!HLListWidget methodsFor: 'events'!
+
+setupKeyBindings 
+	(HLRepeatedKeyDownHandler on: self)
+		whileKeyDown: 38 do: [ self activatePreviousListItem ];
+		whileKeyDown: 40 do: [ self activateNextListItem ];
+		rebindKeys.
+		
+	self wrapper asJQuery keydown: [ :e |
+        e which = 13 ifTrue: [ 
+        	self reselectItem: self selectedItem ] ]
+! !
+
+!HLListWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+!
+
+renderContentOn: html
+	html ul 
+    	class: 'nav nav-pills nav-stacked';
+        with: [ self renderListOn: html ].
+    html div class: 'pane_actions form-actions'; with: [
+      	self renderButtonsOn: html ].
+        
+   self setupKeyBindings
+!
+
+renderItem: anObject on: html
+	| li |
+    
+	li := html li.
+	li asJQuery data: 'item' put: anObject.
+    li
+		class: (self listCssClassForItem: anObject);
+        with: [ 
+        	html a
+            	with: [ 
+            		(html tag: 'i') class: (self cssClassForItem: anObject).
+  					self renderItemLabel: anObject on: html ];
+				onClick: [
+                  	self reactivateListItem: li asJQuery ] ]
+!
+
+renderItemLabel: anObject on: html
+	html with: anObject asString
+!
+
+renderListOn: html
+	self items do: [ :each  | 
+    	self renderItem: each  on: html ]
+! !
+
+HLListWidget subclass: #HLNavigationListWidget
+	instanceVariableNames: 'previous next'
+	package: 'Helios-Core'!
+
+!HLNavigationListWidget methodsFor: 'accessing'!
+
+next
+	^ next
+!
+
+next: aWidget
+	next := aWidget.
+    aWidget previous = self ifFalse: [ aWidget previous: self ]
+!
+
+previous
+	^ previous
+!
+
+previous: aWidget
+	previous := aWidget.
+    aWidget next = self ifFalse: [ aWidget next: self ]
+! !
+
+!HLNavigationListWidget methodsFor: 'actions'!
+
+nextFocus
+	self next ifNotNil: [ self next focus ]
+!
+
+previousFocus
+	self previous ifNotNil: [ self previous focus ]
+! !
+
+!HLNavigationListWidget methodsFor: 'events'!
+
+setupKeyBindings
+	super setupKeyBindings.
+
+	self wrapper asJQuery keydown: [ :e |
+        e which = 39 ifTrue: [ 
+        	self nextFocus ].
+		e which = 37 ifTrue: [ 
+        	self previousFocus ] ]
+! !
+
+HLNavigationListWidget subclass: #HLToolListWidget
+	instanceVariableNames: 'model'
+	package: 'Helios-Core'!
+
+!HLToolListWidget methodsFor: 'accessing'!
+
+commandCategory
+	^ self label
+!
+
+label
+	^ 'List'
+!
+
+menuCommands
+	"Answer a collection of commands to be put in the cog menu"
+	
+	^ ((HLToolCommand concreteClasses
+		select: [ :each | each isValidFor: self model ])
+			collect: [ :each | each for: self model ])
+			select: [ :each | 
+				each category = self commandCategory and: [ 
+					each isAction and: [ each isActive ] ] ]
+!
+
+model
+	^ model
+!
+
+model: aBrowserModel
+	model := aBrowserModel.
+    
+    self 
+		observeSystem;
+		observeModel
+!
+
+selectedItem: anItem
+	"Selection changed, update the cog menu"
+	
+	super selectedItem: anItem.
+	self updateMenu
+! !
+
+!HLToolListWidget methodsFor: 'actions'!
+
+activateListItem: anItem
+	self model withChangesDo: [ super activateListItem: anItem ]
+!
+
+activateNextListItem
+	self model withChangesDo: [ super activateNextListItem ]
+!
+
+activatePreviousListItem
+	self model withChangesDo: [ super activatePreviousListItem ]
+!
+
+observeModel
+!
+
+observeSystem
+!
+
+reactivateListItem: anItem
+	self model withChangesDo: [ super reactivateListItem: anItem ]
+!
+
+unregister
+	super unregister.
+	
+	self model announcer unsubscribe: self.
+	self model systemAnnouncer unsubscribe: self
+! !
+
+!HLToolListWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	self renderHeadOn: html.	
+	super renderContentOn: html
+!
+
+renderHeadOn: html
+	html div 
+		class: 'list-label';
+		with: [
+			html with: self label.
+			self renderMenuOn: html ]
+!
+
+renderMenuOn: html
+	| commands |
+	
+	commands := self menuCommands.
+	commands isEmpty ifTrue: [ ^ self ].
+	
+	html div 
+		class: 'btn-group cog';
+		with: [
+			html a
+				class: 'btn dropdown-toggle';
+				at: 'data-toggle' put: 'dropdown';
+				with: [ (html tag: 'i') class: 'icon-chevron-down' ].
+		html ul 
+			class: 'dropdown-menu pull-right';
+			with: [ 
+				self menuCommands do: [ :each | 
+					html li with: [ html a 
+						with: each menuLabel;
+						onClick: [ self execute: each ] ] ] ] ]
+! !
+
+!HLToolListWidget methodsFor: 'updating'!
+
+updateMenu
+	(self wrapper asJQuery find: '.cog') remove.
+	
+	[ :html | self renderMenuOn: html ] 
+		appendToJQuery: (self wrapper asJQuery find: '.list-label')
+! !
+
+!HLToolListWidget class methodsFor: 'instance creation'!
+
+on: aModel
+	^ self new 
+    	model: aModel;
+        yourself
+! !
+
+HLListWidget subclass: #HLTabListWidget
+	instanceVariableNames: 'callback'
+	package: 'Helios-Core'!
+!HLTabListWidget commentStamp!
+I am a widget used to display a list of helios tabs.
+
+When a tab is selected, `callback` is evaluated with the selected tab as argument.!
+
+!HLTabListWidget methodsFor: 'accessing'!
+
+callback
+	^ callback ifNil: [ [] ]
+!
+
+callback: aBlock
+	callback := aBlock
+! !
+
+!HLTabListWidget methodsFor: 'actions'!
+
+selectItem: aTab
+	super selectItem: aTab.
+	self callback value: aTab
+! !
+
+!HLTabListWidget methodsFor: 'rendering'!
+
+renderItemLabel: aTab on: html
+	html span
+		class: aTab cssClass;
+		with: aTab label
+! !
+
+HLWidget subclass: #HLInformationWidget
+	instanceVariableNames: 'informationString'
+	package: 'Helios-Core'!
+!HLInformationWidget commentStamp!
+I display an information dialog.
+
+## API
+
+`HLWidget >> #inform:` is a convenience method for creating information dialogs.!
+
+!HLInformationWidget methodsFor: 'accessing'!
+
+informationString
+	^ informationString ifNil: [ '' ]
+!
+
+informationString: anObject
+	informationString := anObject
+! !
+
+!HLInformationWidget methodsFor: 'actions'!
+
+remove
+	[ 
+		self wrapper asJQuery fadeOut: 100.
+		[ self wrapper asJQuery remove ]
+			valueWithTimeout: 400.
+	]
+		valueWithTimeout: 1500
+!
+
+show
+	self appendToJQuery: 'body' asJQuery
+! !
+
+!HLInformationWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	html div 
+		class: 'growl'; 
+		with: self informationString.
+		
+	self remove
+! !
+
+HLWidget subclass: #HLManager
+	instanceVariableNames: 'tabsWidget environment history announcer'
+	package: 'Helios-Core'!
+
+!HLManager methodsFor: 'accessing'!
+
+activeTab
+	^ self tabsWidget activeTab
+!
+
+announcer
+	^ announcer ifNil: [ announcer := Announcer new ]
+!
+
+environment
+	"The default environment used by all Helios objects"
+    
+	^ environment ifNil: [ environment := self defaultEnvironment ]
+!
+
+environment: anEnvironment
+	environment := anEnvironment
+!
+
+history
+	^ history ifNil: [ history := OrderedCollection new ]
+!
+
+history: aCollection
+	history := aCollection
+!
+
+keyBinder
+	^ HLKeyBinder current
+!
+
+setEditorTheme: aTheme
+
+	'helios.editorTheme' asSetting value: aTheme
+!
+
+setTheme: aTheme
+	| currentTheme |
+
+	currentTheme := 'helios.theme' asSettingIfAbsent: 'default'.
+	
+	'body' asJQuery
+		removeClass: currentTheme value;
+		addClass: aTheme.
+		
+	
+	'helios.theme' asSetting value: aTheme
+!
+
+tabWidth
+	^ (window asJQuery width - 90) / self tabs size
+!
+
+tabs
+	^ self tabsWidget tabs
+!
+
+tabsWidget
+	^ tabsWidget ifNil: [ tabsWidget := HLTabsWidget new ]
+! !
+
+!HLManager methodsFor: 'actions'!
+
+activate: aTab
+	self tabsWidget activate: aTab
+!
+
+addTab: aTab
+	self tabsWidget addTab: aTab
+!
+
+confirm: aString ifFalse: aBlock
+	self 
+		confirm: aString
+		ifTrue: []
+		ifFalse: aBlock
+!
+
+confirm: aString ifTrue: aBlock
+	self 
+		confirm: aString
+		ifTrue: aBlock
+		ifFalse: []
+!
+
+confirm: aString ifTrue: aBlock ifFalse: anotherBlock
+	HLConfirmationWidget new
+		confirmationString: aString;
+		actionBlock: aBlock;
+		cancelBlock: anotherBlock;
+		show
+!
+
+inform: aString
+	HLInformationWidget new
+		informationString: aString;
+		show
+!
+
+removeActiveTab
+	self tabsWidget removeActiveTab
+!
+
+removeTabForWidget: aWidget
+	self tabsWidget removeTabForWidget: aWidget
+!
+
+request: aString do: aBlock
+	self 
+		request: aString
+		value: ''
+		do: aBlock
+!
+
+request: aString value: valueString do: aBlock
+	HLRequestWidget new
+		confirmationString: aString;
+		actionBlock: aBlock;
+		value: valueString;
+		show
+! !
+
+!HLManager methodsFor: 'defaults'!
+
+defaultEnvironment
+	"If helios is loaded from within a frame, answer the parent window environment"
+	
+	| parent parentSmalltalkGlobals |
+	
+	parent := window opener ifNil: [ window parent ].
+	parent ifNil: [ ^ Environment new ].
+	
+	parentSmalltalkGlobals := (parent at: 'requirejs') value: 'amber_vm/globals'.
+	parentSmalltalkGlobals ifNil: [ ^ Environment new ].
+	
+	^ (parentSmalltalkGlobals at: 'Environment') new
+! !
+
+!HLManager methodsFor: 'initialization'!
+
+setup
+	self 
+		registerServices;
+		setupEvents.
+    self keyBinder setupEvents.
+	self tabsWidget setupEvents.
+	self setupTheme.
+	
+	
+	'#helper' asJQuery fadeOut
+! !
+
+!HLManager methodsFor: 'private'!
+
+registerServices
+	self
+		registerInspector;
+		registerErrorHandler;
+		registerProgressHandler;
+		registerTranscript;
+		registerFinder
+!
+
+setupEvents
+	'body' asJQuery keydown: [ :event |
+			
+		"On ctrl keydown, adds a 'navigation' css class to <body>
+		for the CodeMirror navigation links. See `HLCodeWidget`."
+		event ctrlKey ifTrue: [
+			'body' asJQuery addClass: 'navigation' ] ].
+			
+	'body' asJQuery keyup: [ :event |
+		'body' asJQuery removeClass: 'navigation' ].
+		
+	window asJQuery resize: [ :event |
+		self refresh ]
+!
+
+setupTheme
+	"self 
+		setTheme: 'niflheim';
+		setEditorTheme: 'niflheim'."
+		
+	self 
+		setTheme: 'default';
+		setEditorTheme: 'default'.
+! !
+
+!HLManager methodsFor: 'rendering'!
+
+renderContentOn: html
+	html with: self tabsWidget.
+	html with: HLWelcomeWidget new
+! !
+
+!HLManager methodsFor: 'services'!
+
+registerErrorHandler
+	self environment registerErrorHandler: HLErrorHandler new.
+	ErrorHandler register: HLErrorHandler new
+!
+
+registerFinder
+	self environment registerFinder: HLFinder new.
+	Finder register: HLFinder new
+!
+
+registerInspector
+	self environment registerInspector: HLInspector.
+	Inspector register: HLInspector
+!
+
+registerProgressHandler
+	self environment registerProgressHandler: HLProgressHandler new.
+	ProgressHandler register: HLProgressHandler new
+!
+
+registerTranscript
+	self environment registerTranscript: HLTranscriptHandler
+! !
+
+HLManager class instanceVariableNames: 'current'!
+
+!HLManager class methodsFor: 'accessing'!
+
+current
+	^ current ifNil: [ current := self basicNew initialize ]
+! !
+
+!HLManager class methodsFor: 'initialization'!
+
+setup
+	self current 
+		setup;
+		appendToJQuery: 'body' asJQuery
+! !
+
+!HLManager class methodsFor: 'instance creation'!
+
+new
+	"Use current instead"
+
+	self shouldNotImplement
+! !
+
+HLWidget subclass: #HLModalWidget
+	instanceVariableNames: ''
+	package: 'Helios-Core'!
+!HLModalWidget commentStamp!
+I implement an abstract modal widget.!
+
+!HLModalWidget methodsFor: 'actions'!
+
+remove
+	'.dialog' asJQuery removeClass: 'active'.
+	[ 
+		'#overlay' asJQuery remove.
+		wrapper asJQuery remove
+	] valueWithTimeout: 300
+!
+
+show
+	self appendToJQuery: 'body' asJQuery
+! !
+
+!HLModalWidget methodsFor: 'private'!
+
+giveFocusToButton: aButton
+	aButton asJQuery focus
+! !
+
+!HLModalWidget methodsFor: 'rendering'!
+
+hasButtons
+	^ true
+!
+
+renderButtonsOn: html
+!
+
+renderContentOn: html
+	| confirmButton |
+	
+	html div id: 'overlay'.
+	
+	html div 
+		class: 'dialog ', self cssClass;
+		with: [
+			self renderMainOn: html.
+			self hasButtons ifTrue: [ 
+				self renderButtonsOn: html ] ].
+
+	'.dialog' asJQuery addClass: 'active'.
+	self setupKeyBindings
+!
+
+renderMainOn: html
+!
+
+setupKeyBindings
+	'.dialog' asJQuery keyup: [ :e |
+		e keyCode = String esc asciiValue ifTrue: [ self cancel ] ]
+! !
+
+HLModalWidget subclass: #HLConfirmationWidget
+	instanceVariableNames: 'cancelButtonLabel confirmButtonLabel confirmationString actionBlock cancelBlock'
+	package: 'Helios-Core'!
+!HLConfirmationWidget commentStamp!
+I display confirmation dialog. 
+
+## API
+
+HLWidget contains convenience methods like `HLWidget >> #confirm:ifTrue:` for creating confirmation dialogs.!
+
+!HLConfirmationWidget methodsFor: 'accessing'!
+
+actionBlock
+	^ actionBlock ifNil: [ [] ]
+!
+
+actionBlock: aBlock
+	actionBlock := aBlock
+!
+
+cancelBlock
+	^ cancelBlock ifNil: [ [] ]
+!
+
+cancelBlock: aBlock
+	cancelBlock := aBlock
+!
+
+cancelButtonLabel
+	^ cancelButtonLabel ifNil: [ 'Cancel' ]
+!
+
+cancelButtonLabel: aString
+	^ cancelButtonLabel := aString
+!
+
+confirmButtonLabel
+	^ confirmButtonLabel ifNil: [ 'Confirm' ]
+!
+
+confirmButtonLabel: aString
+	^ confirmButtonLabel := aString
+!
+
+confirmationString
+	^ confirmationString ifNil: [ 'Confirm' ]
+!
+
+confirmationString: aString
+	confirmationString := aString
+! !
+
+!HLConfirmationWidget methodsFor: 'actions'!
+
+cancel
+	self cancelBlock value.
+	self remove
+!
+
+confirm
+	self remove.
+	self actionBlock value
+! !
+
+!HLConfirmationWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	| confirmButton |
+	
+	html div 
+		class: 'buttons';
+		with: [
+			html button
+				class: 'button';
+				with: self cancelButtonLabel;
+				onClick: [ self cancel ].
+			confirmButton := html button
+				class: 'button default';
+				with: self confirmButtonLabel;
+				onClick: [ self confirm ] ].
+
+	self giveFocusToButton:confirmButton
+!
+
+renderMainOn: html
+	html span 
+		class: 'head'; 
+		with: self confirmationString
+! !
+
+HLConfirmationWidget subclass: #HLRequestWidget
+	instanceVariableNames: 'input multiline value'
+	package: 'Helios-Core'!
+!HLRequestWidget commentStamp!
+I display a modal window requesting user input.
+
+## API
+
+`HLWidget >> #request:do:` and `#request:value:do:` are convenience methods for creating modal request dialogs.!
+
+!HLRequestWidget methodsFor: 'accessing'!
+
+beMultiline
+	multiline := true
+!
+
+beSingleline
+	multiline := false
+!
+
+cssClass
+	^ 'large'
+!
+
+value
+	^ value ifNil: [ '' ]
+!
+
+value: aString
+	value := aString
+! !
+
+!HLRequestWidget methodsFor: 'actions'!
+
+confirm
+	| val |
+	val := input asJQuery val.
+	self remove.
+	self actionBlock value: val
+! !
+
+!HLRequestWidget methodsFor: 'private'!
+
+giveFocusToButton: aButton
+! !
+
+!HLRequestWidget methodsFor: 'rendering'!
+
+renderMainOn: html
+	super renderMainOn: html.
+	self isMultiline
+		ifTrue: [ input := html textarea ]
+		ifFalse: [ input := html input 
+			type: 'text';
+			onKeyDown: [ :event |
+				event keyCode = 13 ifTrue: [
+					self confirm ] ];
+			yourself ].
+	input asJQuery 
+		val: self value;
+		focus
+! !
+
+!HLRequestWidget methodsFor: 'testing'!
+
+isMultiline
+	^ multiline ifNil: [ true ]
+! !
+
+HLModalWidget subclass: #HLProgressWidget
+	instanceVariableNames: 'progressBars visible'
+	package: 'Helios-Core'!
+!HLProgressWidget commentStamp!
+I am a widget used to display progress modal dialogs.
+
+My default instance is accessed with `HLProgressWidget class >> #default`.
+
+See `HLProgressHandler` for usage.!
+
+!HLProgressWidget methodsFor: 'accessing'!
+
+progressBars
+	^ progressBars ifNil: [ progressBars := OrderedCollection new ]
+! !
+
+!HLProgressWidget methodsFor: 'actions'!
+
+addProgressBar: aProgressBar
+	self show.
+	self progressBars add: aProgressBar.
+	aProgressBar appendToJQuery: (self wrapper asJQuery find: '.dialog')
+!
+
+do: aBlock on: aCollection displaying: aString
+	| progressBar |
+	
+	progressBar := HLProgressBarWidget new
+		parent: self;
+		label: aString;
+		workBlock: aBlock;
+		collection: aCollection;
+		yourself.
+	
+	self addProgressBar: progressBar.
+	progressBar start
+!
+
+flush
+	self progressBars do: [ :each |
+		self removeProgressBar: each ]
+!
+
+remove
+	self isVisible ifTrue: [
+		visible := false.
+		super remove ]
+!
+
+removeProgressBar: aProgressBar
+	self progressBars remove: aProgressBar ifAbsent: [].
+	aProgressBar wrapper asJQuery remove.
+	
+	self progressBars ifEmpty: [ self remove ]
+!
+
+show
+	self isVisible ifFalse: [
+		visible := true.
+		super show ]
+! !
+
+!HLProgressWidget methodsFor: 'rendering'!
+
+renderMainOn: html
+	self progressBars do: [ :each |
+		html with: each ]
+! !
+
+!HLProgressWidget methodsFor: 'testing'!
+
+hasButtons
+	^ false
+!
+
+isVisible
+	^ visible ifNil: [ false ]
+! !
+
+HLProgressWidget class instanceVariableNames: 'default'!
+
+!HLProgressWidget class methodsFor: 'accessing'!
+
+default
+	^ default ifNil: [ default := self new ]
+! !
+
+HLModalWidget subclass: #HLTabSelectionWidget
+	instanceVariableNames: 'tabs tabList selectedTab selectCallback cancelCallback confirmCallback'
+	package: 'Helios-Core'!
+!HLTabSelectionWidget commentStamp!
+I am a modal window used to select or create tabs.!
+
+!HLTabSelectionWidget methodsFor: 'accessing'!
+
+cancelCallback
+	^ cancelCallback ifNil: [ [] ]
+!
+
+cancelCallback: aBlock
+	cancelCallback := aBlock
+!
+
+confirmCallback
+	^ confirmCallback ifNil: [ [] ]
+!
+
+confirmCallback: aBlock
+	confirmCallback := aBlock
+!
+
+selectCallback
+	^ selectCallback ifNil: [ [] ]
+!
+
+selectCallback: aBlock
+	selectCallback := aBlock
+!
+
+selectedTab
+	^ selectedTab
+!
+
+selectedTab: aTab
+	selectedTab := aTab
+!
+
+tabs
+	^ tabs ifNil: [ #() ]
+!
+
+tabs: aCollection
+	tabs := aCollection
+! !
+
+!HLTabSelectionWidget methodsFor: 'actions'!
+
+cancel
+	self remove.
+	self cancelCallback value
+!
+
+confirm
+	self remove.
+	self confirmCallback value: self selectedTab
+!
+
+selectTab: aTab
+	self selectedTab: aTab.
+	self selectCallback value: aTab
+!
+
+setupKeyBindings
+	super setupKeyBindings.
+	'.dialog' asJQuery keyup: [ :e |
+		e keyCode = String cr asciiValue ifTrue: [ self confirm ] ]
+! !
+
+!HLTabSelectionWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	| confirmButton |
+	
+	html div 
+		class: 'buttons';
+		with: [
+			html button
+				class: 'button';
+				with: 'Cancel';
+				onClick: [ self cancel ].
+			confirmButton := html button
+				class: 'button default';
+				with: 'Select tab';
+				onClick: [ self confirm ] ].
+
+	self giveFocusToButton:confirmButton
+!
+
+renderContentOn: html
+	super renderContentOn: html.
+	self tabList focus
+!
+
+renderMainOn: html
+	html div 
+		class: 'title'; 
+		with: 'Tab selection'.
+	
+	html with: self tabList
+!
+
+renderTab: aTab on: html
+	html 
+		span 
+			class: aTab cssClass;
+			with: aTab label
+!
+
+renderTabsOn: html
+	self tabs do: [ :each |
+		html li with: [ 
+			html a 
+				with: [ 
+					self renderTab: each on: html ];
+				onClick: [ self selectTab: each ] ] ]
+!
+
+tabList
+	tabList ifNil: [ 
+		tabList := HLTabListWidget new.
+		tabList
+			callback: [ :tab | self selectTab: tab. tabList focus ];
+			selectedItem: self selectedTab;
+			items: self tabs ].
+	
+	^ tabList
+! !
+
+HLWidget subclass: #HLProgressBarWidget
+	instanceVariableNames: 'label parent workBlock collection bar'
+	package: 'Helios-Core'!
+!HLProgressBarWidget commentStamp!
+I am a widget used to display a progress bar while iterating over a collection.!
+
+!HLProgressBarWidget methodsFor: 'accessing'!
+
+collection
+	^ collection
+!
+
+collection: aCollection
+	collection := aCollection
+!
+
+label
+	^ label
+!
+
+label: aString
+	label := aString
+!
+
+parent
+	^ parent
+!
+
+parent: aProgress
+	parent := aProgress
+!
+
+workBlock
+	^ workBlock
+!
+
+workBlock: aBlock
+	workBlock := aBlock
+! !
+
+!HLProgressBarWidget methodsFor: 'actions'!
+
+evaluateAt: anInteger
+	self updateProgress: (anInteger / self collection size) * 100.
+	anInteger <= self collection size
+		ifTrue: [ 
+			[ 
+				self workBlock value: (self collection at: anInteger).
+				self evaluateAt: anInteger + 1 ] valueWithTimeout: 10 ]
+		ifFalse: [ [ self remove ] valueWithTimeout: 500 ]
+!
+
+remove
+	self parent removeProgressBar: self
+!
+
+start
+	"Make sure the UI has some time to update itself between each iteration"
+	
+	self evaluateAt: 1
+!
+
+updateProgress: anInteger
+	bar asJQuery css: 'width' put: anInteger asString, '%'
+! !
+
+!HLProgressBarWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	html span with: self label.
+	html div 
+		class: 'progress';
+		with: [
+			bar := html div 
+				class: 'bar';
+				style: 'width: 0%' ]
+! !
+
+HLProgressBarWidget class instanceVariableNames: 'default'!
+
+!HLProgressBarWidget class methodsFor: 'accessing'!
+
+default
+	^ default ifNil: [ default := self new ]
+! !
+
+HLWidget subclass: #HLTabWidget
+	instanceVariableNames: 'widget label root'
+	package: 'Helios-Core'!
+!HLTabWidget commentStamp!
+I am a widget specialized into building another widget as an Helios tab.
+
+I should not be used directly, `HLWidget class >> #openAsTab` should be used instead.
+
+## Example
+
+    HLWorkspace openAsTab!
+
+!HLTabWidget methodsFor: 'accessing'!
+
+activate
+	self manager activate: self
+!
+
+cssClass
+	^ self widget tabClass
+!
+
+focus
+	self widget canHaveFocus ifTrue: [
+		self widget focus ]
+!
+
+label
+	^ label ifNil: [ '' ]
+!
+
+label: aString
+	label := aString
+!
+
+manager
+	^ HLManager current
+!
+
+widget
+	^ widget
+!
+
+widget: aWidget
+	widget := aWidget
+! !
+
+!HLTabWidget methodsFor: 'actions'!
+
+add
+	self manager addTab: self.
+	self observeManager
+!
+
+hide
+	root ifNotNil: [ root asJQuery css: 'visibility' put: 'hidden' ]
+!
+
+observeManager
+	self manager announcer 
+		on: HLTabLabelChanged
+		send: #onTabLabelChanged:
+		to: self
+!
+
+registerBindings
+	self widget registerBindings
+!
+
+remove
+	self unregister.
+	self widget unregister.
+	root ifNotNil: [ root asJQuery remove ]
+!
+
+show
+	root
+		ifNil: [ self appendToJQuery: 'body' asJQuery ]
+		ifNotNil: [ root asJQuery css: 'visibility' put: 'visible' ]
+!
+
+unregister
+	self manager announcer unsubscribe: self
+! !
+
+!HLTabWidget methodsFor: 'reactions'!
+
+onTabLabelChanged: anAnnouncement
+	anAnnouncement widget = self widget ifTrue: [
+		self label = anAnnouncement label ifFalse: [
+			self label: anAnnouncement label.
+			self manager refresh ] ]
+! !
+
+!HLTabWidget methodsFor: 'rendering'!
+
+renderOn: html
+	root := html div
+		class: 'tab';
+		yourself.
+	self renderTab
+!
+
+renderTab
+	root contents: [ :html |
+		html div
+			class: 'amber_box';
+			with: [ self widget renderOn: html ] ]
+! !
+
+!HLTabWidget methodsFor: 'testing'!
+
+isActive
+	^ self manager activeTab = self
+! !
+
+!HLTabWidget class methodsFor: 'instance creation'!
+
+on: aWidget labelled: aString
+	^ self new
+		widget: aWidget;
+		label: aString;
+		yourself
+! !
+
+HLWidget subclass: #HLTabsWidget
+	instanceVariableNames: 'tabs activeTab history selectionDisabled'
+	package: 'Helios-Core'!
+
+!HLTabsWidget methodsFor: 'accessing'!
+
+activeTab
+	^ activeTab
+!
+
+history
+	^ history ifNil: [ history := OrderedCollection new ]
+!
+
+history: aCollection
+	history := aCollection
+!
+
+tabWidth
+	^ (window asJQuery width - 90) / self tabs size
+!
+
+tabs
+	^ tabs ifNil: [ tabs := OrderedCollection new ]
+! !
+
+!HLTabsWidget methodsFor: 'actions'!
+
+activate: aTab
+	self isSelectionDisabled ifTrue: [ ^ self ].
+
+	self manager keyBinder flushBindings.
+	aTab registerBindings.
+	activeTab := aTab.
+	
+	self 
+		refresh;
+		addToHistory: aTab;
+		show: aTab
+!
+
+activateNextTab
+	| nextTab |
+	
+	self tabs ifEmpty: [ ^ self ].
+	
+	nextTab := self tabs 
+		at: (self tabs indexOf: self activeTab) + 1 
+		ifAbsent: [ self tabs first ].
+		
+	self activate: nextTab
+!
+
+activatePreviousTab
+	| previousTab |
+	
+	self tabs ifEmpty: [ ^ self ].
+	
+	previousTab := self tabs 
+		at: (self tabs indexOf: self activeTab) - 1 
+		ifAbsent: [ self tabs last ].
+		
+	self activate: previousTab
+!
+
+addTab: aTab
+	self tabs add: aTab.
+    self activate: aTab
+!
+
+addToHistory: aTab
+	self removeFromHistory: aTab.
+	self history add: aTab
+!
+
+disableSelection
+	selectionDisabled := true
+!
+
+enableSelection
+	selectionDisabled := false
+!
+
+removeActiveTab
+	self removeTab: self activeTab
+!
+
+removeFromHistory: aTab
+	self history: (self history reject: [ :each | each == aTab ])
+!
+
+removeTab: aTab
+	(self tabs includes: aTab) ifFalse: [ ^ self ].
+
+	self removeFromHistory: aTab.
+	self tabs remove: aTab.
+	self manager keyBinder flushBindings.
+	aTab remove.
+	self refresh.
+	self history ifNotEmpty: [
+		self history last activate ]
+!
+
+removeTabForWidget: aWidget
+	self removeTab: (self tabs 
+		detect: [ :each | each widget = aWidget ]
+		ifNone: [ ^ self ])
+!
+
+updateTabsOrder
+	tabs := '.main-tabs li' asJQuery toArray 
+		collect: [ :each | each at: 'tab-data' ]
+! !
+
+!HLTabsWidget methodsFor: 'private'!
+
+setupEvents
+	'body' asJQuery keydown: [ :event |
+	
+		"ctrl+> and ctrl+<"
+		(event ctrlKey and: [ event which = 188 ]) ifTrue: [
+			self activatePreviousTab.
+			event preventDefault ].
+		(event ctrlKey and: [ event which = 190 ]) ifTrue: [
+			self activateNextTab.
+			event preventDefault ] ]
+! !
+
+!HLTabsWidget methodsFor: 'rendering'!
+
+renderAddOn: html
+    html div 
+    	class: 'dropdown new_tab';
+        with: [ 
+			html a 
+        		class: 'dropdown-toggle';
+           	 	at: 'data-toggle' put: 'dropdown';
+            	with: [
+  					(html tag: 'b') class: 'caret' ].
+           html ul 
+           		class: 'dropdown-menu';
+                with: [
+                  	((HLWidget withAllSubclasses
+                    	select: [ :each | each canBeOpenAsTab ])
+                        sorted: [ :a :b | a tabPriority < b tabPriority ])
+                        do: [ :each |
+  							html li with: [
+                      			html a 
+                                	with: each tabLabel;
+      								onClick: [ each openAsTab ] ] ] ] ]
+!
+
+renderContentOn: html
+	html div 
+		class: 'navbar navbar-fixed-top';
+		with: [ html div 
+			class: 'navbar-inner';
+			with: [ self renderTabsOn: html ] ].
+			
+	self renderAddOn: html
+!
+
+renderTab: aTab on: html
+	| li |
+	li := html li 
+		style: 'width: ', self tabWidth asString, 'px';
+		class: (aTab isActive ifTrue: [ 'tab active' ] ifFalse: [ 'tab inactive' ]);
+		with: [
+			html a
+			with: [
+				((html tag: 'i') class: 'close')
+					onClick: [ self removeTab: aTab ].
+				html span 
+					class: aTab cssClass;
+					title: aTab label;
+					with: aTab label ] ];
+		onClick: [ aTab activate ].
+	
+	(li asJQuery get: 0) at: 'tab-data' put: aTab
+!
+
+renderTabsOn: html
+	| ul |
+	ul := html ul 
+		class: 'nav main-tabs';
+		with: [ 
+        	self tabs do: [ :each |
+				self renderTab: each on: html ] ].
+		
+	ul asJQuery sortable: #{
+		'containment' -> 'parent'.
+		'start' -> [ self disableSelection ].
+		'stop' -> [ [ self enableSelection] valueWithTimeout: 300 ].
+		'update' -> [ self updateTabsOrder ]
+	}
+!
+
+show: aTab
+	self tabs do: [ :each | each hide ].
+	aTab show; focus
+! !
+
+!HLTabsWidget methodsFor: 'testing'!
+
+isSelectionDisabled
+	^ selectionDisabled ifNil: [ false ]
+! !
+
+HLTabsWidget class instanceVariableNames: 'current'!
+
+HLWidget subclass: #HLWelcomeWidget
+	instanceVariableNames: ''
+	package: 'Helios-Core'!
+
+!HLWelcomeWidget methodsFor: 'accessing'!
+
+cssClass
+	^ 'welcome'
+! !
+
+!HLWelcomeWidget methodsFor: 'actions'!
+
+openClassBrowser
+	HLBrowser openAsTab
+!
+
+openHelp
+!
+
+openTestRunner
+!
+
+openWorkspace
+	HLWorkspace openAsTab
+! !
+
+!HLWelcomeWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	html button
+		class: 'button';
+		with: 'Class Browser';
+		onClick: [ self openClassBrowser ].
+	html button
+		class: 'button';
+		with: 'Workspace';
+		onClick: [ self openWorkspace ].
+	"html button
+		class: 'button';
+		with: 'Test Runner';
+		onClick: [ self openTestRunner ].
+	html button
+		class: 'button';
+		with: 'Help';
+		onClick: [ self openHelp ]"
+!
+
+renderContentOn: html
+	self
+		renderHelpOn: html;
+		renderButtonsOn: html
+!
+
+renderHelpOn: html
+	html h2 with: 'No tools are open'.
+	html ul with: [
+		html li with: 'Perform actions with  ctrl + space'.
+		html li with: 'Open one of the common tools:' ]
+! !
+

src/Helios-Debugger.js

@@ -0,0 +1,1483 @@
+define("helios/Helios-Debugger", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "helios/Helios-Core", "helios/Helios-Workspace"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Debugger');
+smalltalk.packages["Helios-Debugger"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLContextInspectorDecorator', globals.Object, ['context'], 'Helios-Debugger');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "context",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@context"];
+return $1;
+},
+args: [],
+source: "context\x0a\x09^ context",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLContextInspectorDecorator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "evaluate:on:",
+protocol: 'evaluating',
+fn: function (aString,anEvaluator){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._context())._evaluate_on_(aString,anEvaluator);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"evaluate:on:",{aString:aString,anEvaluator:anEvaluator},globals.HLContextInspectorDecorator)})},
+args: ["aString", "anEvaluator"],
+source: "evaluate: aString on: anEvaluator\x0a\x09^ self context evaluate: aString on: anEvaluator",
+messageSends: ["evaluate:on:", "context"],
+referencedClasses: []
+}),
+globals.HLContextInspectorDecorator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeFromContext:",
+protocol: 'initialization',
+fn: function (aContext){
+var self=this;
+self["@context"]=aContext;
+return self},
+args: ["aContext"],
+source: "initializeFromContext: aContext\x0a\x09context := aContext",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLContextInspectorDecorator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectOn:",
+protocol: 'inspecting',
+fn: function (anInspector){
+var self=this;
+var variables,inspectedContext;
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$receiver;
+variables=_st($Dictionary())._new();
+inspectedContext=self._context();
+$1=variables;
+$2=_st(inspectedContext)._locals();
+$ctx1.sendIdx["locals"]=1;
+_st($1)._addAll_($2);
+$ctx1.sendIdx["addAll:"]=1;
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(inspectedContext)._notNil())._and_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(inspectedContext)._isBlockContext();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._whileTrue_((function(){
+return smalltalk.withContext(function($ctx2) {
+inspectedContext=_st(inspectedContext)._outerContext();
+inspectedContext;
+$3=inspectedContext;
+if(($receiver = $3) == null || $receiver.isNil){
+return $3;
+} else {
+return _st(variables)._addAll_(_st(inspectedContext)._locals());
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+_st(anInspector)._setLabel_("Context");
+$4=_st(anInspector)._setVariables_(variables);
+return self}, function($ctx1) {$ctx1.fill(self,"inspectOn:",{anInspector:anInspector,variables:variables,inspectedContext:inspectedContext},globals.HLContextInspectorDecorator)})},
+args: ["anInspector"],
+source: "inspectOn: anInspector\x0a\x09| variables inspectedContext |\x0a\x09\x0a\x09variables := Dictionary new.\x0a\x09inspectedContext := self context.\x0a\x09\x0a\x09variables addAll: inspectedContext locals.\x0a\x09\x0a\x09[ inspectedContext notNil and: [ inspectedContext isBlockContext ] ] whileTrue: [\x0a\x09\x09inspectedContext := inspectedContext outerContext.\x0a\x09\x09inspectedContext ifNotNil: [\x0a\x09\x09\x09variables addAll: inspectedContext locals ] ].\x0a\x09\x0a\x09anInspector\x0a\x09\x09setLabel: 'Context';\x0a\x09\x09setVariables: variables",
+messageSends: ["new", "context", "addAll:", "locals", "whileTrue:", "and:", "notNil", "isBlockContext", "outerContext", "ifNotNil:", "setLabel:", "setVariables:"],
+referencedClasses: ["Dictionary"]
+}),
+globals.HLContextInspectorDecorator);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aContext){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._initializeFromContext_(aContext);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aContext:aContext},globals.HLContextInspectorDecorator.klass)})},
+args: ["aContext"],
+source: "on: aContext\x0a\x09^ self new\x0a\x09\x09initializeFromContext: aContext;\x0a\x09\x09yourself",
+messageSends: ["initializeFromContext:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLContextInspectorDecorator.klass);
+
+
+smalltalk.addClass('HLDebugger', globals.HLFocusableWidget, ['model', 'stackListWidget', 'codeWidget', 'inspectorWidget'], 'Helios-Debugger');
+globals.HLDebugger.comment="I am the main widget for the Helios debugger.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "codeWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLDebuggerCodeWidget(){return globals.HLDebuggerCodeWidget||(typeof HLDebuggerCodeWidget=="undefined"?nil:HLDebuggerCodeWidget)}
+function $HLDebuggerCodeModel(){return globals.HLDebuggerCodeModel||(typeof HLDebuggerCodeModel=="undefined"?nil:HLDebuggerCodeModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$6,$7,$8,$9,$5,$10,$1,$receiver;
+$2=self["@codeWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLDebuggerCodeWidget())._new();
+$ctx1.sendIdx["new"]=1;
+$4=$3;
+$6=_st($HLDebuggerCodeModel())._new();
+$7=$6;
+$8=self._model();
+$ctx1.sendIdx["model"]=1;
+_st($7)._debuggerModel_($8);
+$9=_st($6)._yourself();
+$ctx1.sendIdx["yourself"]=1;
+$5=$9;
+_st($4)._model_($5);
+_st($3)._browserModel_(self._model());
+$10=_st($3)._yourself();
+self["@codeWidget"]=$10;
+$1=self["@codeWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"codeWidget",{},globals.HLDebugger)})},
+args: [],
+source: "codeWidget\x0a\x09^ codeWidget ifNil: [ codeWidget := HLDebuggerCodeWidget new\x0a\x09\x09model: (HLDebuggerCodeModel new\x0a\x09\x09\x09debuggerModel: self model;\x0a\x09\x09\x09yourself);\x0a\x09\x09browserModel: self model;\x0a\x09\x09yourself ]",
+messageSends: ["ifNil:", "model:", "new", "debuggerModel:", "model", "yourself", "browserModel:"],
+referencedClasses: ["HLDebuggerCodeWidget", "HLDebuggerCodeModel"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=($ctx1.supercall = true, globals.HLDebugger.superclass.fn.prototype._cssClass.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st($2).__comma(" hl_debugger");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLDebugger)})},
+args: [],
+source: "cssClass\x0a\x09^ super cssClass, ' hl_debugger'",
+messageSends: [",", "cssClass"],
+referencedClasses: []
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._stackListWidget())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLDebugger)})},
+args: [],
+source: "focus\x0a\x09self stackListWidget focus",
+messageSends: ["focus", "stackListWidget"],
+referencedClasses: []
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeFromError:",
+protocol: 'initialization',
+fn: function (anError){
+var self=this;
+function $HLDebuggerModel(){return globals.HLDebuggerModel||(typeof HLDebuggerModel=="undefined"?nil:HLDebuggerModel)}
+return smalltalk.withContext(function($ctx1) { 
+self["@model"]=_st($HLDebuggerModel())._on_(anError);
+self._observeModel();
+return self}, function($ctx1) {$ctx1.fill(self,"initializeFromError:",{anError:anError},globals.HLDebugger)})},
+args: ["anError"],
+source: "initializeFromError: anError\x0a\x09model := HLDebuggerModel on: anError.\x0a\x09self observeModel",
+messageSends: ["on:", "observeModel"],
+referencedClasses: ["HLDebuggerModel"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectorWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLInspectorWidget(){return globals.HLInspectorWidget||(typeof HLInspectorWidget=="undefined"?nil:HLInspectorWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@inspectorWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@inspectorWidget"]=_st($HLInspectorWidget())._new();
+$1=self["@inspectorWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inspectorWidget",{},globals.HLDebugger)})},
+args: [],
+source: "inspectorWidget\x0a\x09^ inspectorWidget ifNil: [ \x0a\x09\x09inspectorWidget := HLInspectorWidget new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HLInspectorWidget"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLDebuggerModel(){return globals.HLDebuggerModel||(typeof HLDebuggerModel=="undefined"?nil:HLDebuggerModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@model"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@model"]=_st($HLDebuggerModel())._new();
+$1=self["@model"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLDebugger)})},
+args: [],
+source: "model\x0a\x09^ model ifNil: [ model := HLDebuggerModel new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HLDebuggerModel"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerProceeded(){return globals.HLDebuggerProceeded||(typeof HLDebuggerProceeded=="undefined"?nil:HLDebuggerProceeded)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_send_to_($HLDebuggerContextSelected(),"onContextSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($HLDebuggerStepped(),"onDebuggerStepped:",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+$2=_st($1)._on_send_to_($HLDebuggerProceeded(),"onDebuggerProceeded",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLDebugger)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer \x0a\x09\x09on: HLDebuggerContextSelected\x0a\x09\x09send: #onContextSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLDebuggerStepped\x0a\x09\x09send: #onDebuggerStepped:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLDebuggerProceeded\x0a\x09\x09send: #onDebuggerProceeded\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLDebuggerContextSelected", "HLDebuggerStepped", "HLDebuggerProceeded"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onContextSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+function $HLContextInspectorDecorator(){return globals.HLContextInspectorDecorator||(typeof HLContextInspectorDecorator=="undefined"?nil:HLContextInspectorDecorator)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._inspectorWidget())._inspect_(_st($HLContextInspectorDecorator())._on_(_st(anAnnouncement)._context()));
+return self}, function($ctx1) {$ctx1.fill(self,"onContextSelected:",{anAnnouncement:anAnnouncement},globals.HLDebugger)})},
+args: ["anAnnouncement"],
+source: "onContextSelected: anAnnouncement\x0a\x09self inspectorWidget inspect: (HLContextInspectorDecorator on: anAnnouncement context)",
+messageSends: ["inspect:", "inspectorWidget", "on:", "context"],
+referencedClasses: ["HLContextInspectorDecorator"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onDebuggerProceeded",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._removeTab();
+return self}, function($ctx1) {$ctx1.fill(self,"onDebuggerProceeded",{},globals.HLDebugger)})},
+args: [],
+source: "onDebuggerProceeded\x0a\x09self removeTab",
+messageSends: ["removeTab"],
+referencedClasses: []
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onDebuggerStepped:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+function $HLContextInspectorDecorator(){return globals.HLContextInspectorDecorator||(typeof HLContextInspectorDecorator=="undefined"?nil:HLContextInspectorDecorator)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._atEnd();
+if(smalltalk.assert($1)){
+self._removeTab();
+};
+_st(self._inspectorWidget())._inspect_(_st($HLContextInspectorDecorator())._on_(_st(anAnnouncement)._context()));
+_st(self._stackListWidget())._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onDebuggerStepped:",{anAnnouncement:anAnnouncement},globals.HLDebugger)})},
+args: ["anAnnouncement"],
+source: "onDebuggerStepped: anAnnouncement\x0a\x09self model atEnd ifTrue: [ self removeTab ].\x0a\x09\x0a\x09self inspectorWidget inspect: (HLContextInspectorDecorator on: anAnnouncement context).\x0a\x09self stackListWidget refresh",
+messageSends: ["ifTrue:", "atEnd", "model", "removeTab", "inspect:", "inspectorWidget", "on:", "context", "refresh", "stackListWidget"],
+referencedClasses: ["HLContextInspectorDecorator"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerBindingsOn:",
+protocol: 'keybindings',
+fn: function (aBindingGroup){
+var self=this;
+function $HLToolCommand(){return globals.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLToolCommand())._registerConcreteClassesOn_for_(aBindingGroup,self._model());
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},globals.HLDebugger)})},
+args: ["aBindingGroup"],
+source: "registerBindingsOn: aBindingGroup\x0a\x09HLToolCommand \x0a\x09\x09registerConcreteClassesOn: aBindingGroup \x0a\x09\x09for: self model",
+messageSends: ["registerConcreteClassesOn:for:", "model"],
+referencedClasses: ["HLToolCommand"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+self._renderHeadOn_(html);
+$2=_st($HLVerticalSplitter())._with_with_(self._codeWidget(),_st($HLHorizontalSplitter())._with_with_(self._stackListWidget(),self._inspectorWidget()));
+$ctx1.sendIdx["with:with:"]=1;
+$1=_st($HLContainer())._with_($2);
+_st(html)._with_($1);
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLDebugger)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09self renderHeadOn: html.\x0a\x09html with: (HLContainer with: (HLVerticalSplitter\x0a\x09\x09with: self codeWidget\x0a\x09\x09with: (HLHorizontalSplitter\x0a\x09\x09\x09with: self stackListWidget\x0a\x09\x09\x09with: self inspectorWidget)))",
+messageSends: ["renderHeadOn:", "with:", "with:with:", "codeWidget", "stackListWidget", "inspectorWidget"],
+referencedClasses: ["HLContainer", "HLVerticalSplitter", "HLHorizontalSplitter"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderHeadOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("head");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(html)._h2())._with_(_st(_st(self._model())._error())._messageText());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderHeadOn:",{html:html},globals.HLDebugger)})},
+args: ["html"],
+source: "renderHeadOn: html\x0a\x09html div \x0a\x09\x09class: 'head'; \x0a\x09\x09with: [ html h2 with: self model error messageText ]",
+messageSends: ["class:", "div", "with:", "h2", "messageText", "error", "model"],
+referencedClasses: []
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "stackListWidget",
+protocol: 'widgets',
+fn: function (){
+var self=this;
+function $HLStackListWidget(){return globals.HLStackListWidget||(typeof HLStackListWidget=="undefined"?nil:HLStackListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@stackListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLStackListWidget())._on_(self._model());
+_st($3)._next_(self._codeWidget());
+$4=_st($3)._yourself();
+self["@stackListWidget"]=$4;
+$1=self["@stackListWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"stackListWidget",{},globals.HLDebugger)})},
+args: [],
+source: "stackListWidget\x0a\x09^ stackListWidget ifNil: [ \x0a\x09\x09stackListWidget := (HLStackListWidget on: self model)\x0a\x09\x09\x09next: self codeWidget;\x0a\x09\x09\x09yourself ]",
+messageSends: ["ifNil:", "next:", "on:", "model", "codeWidget", "yourself"],
+referencedClasses: ["HLStackListWidget"]
+}),
+globals.HLDebugger);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLDebugger.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+$ctx1.sendIdx["unregister"]=1;
+_st(self._inspectorWidget())._unregister();
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLDebugger)})},
+args: [],
+source: "unregister\x0a\x09super unregister.\x0a\x09self inspectorWidget unregister",
+messageSends: ["unregister", "inspectorWidget"],
+referencedClasses: []
+}),
+globals.HLDebugger);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (anError){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._initializeFromError_(anError);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anError:anError},globals.HLDebugger.klass)})},
+args: ["anError"],
+source: "on: anError\x0a\x09^ self new\x0a\x09\x09initializeFromError: anError;\x0a\x09\x09yourself",
+messageSends: ["initializeFromError:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLDebugger.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "debugger";
+},
+args: [],
+source: "tabClass\x0a\x09^ 'debugger'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebugger.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Debugger";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'Debugger'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebugger.klass);
+
+
+smalltalk.addClass('HLDebuggerCodeModel', globals.HLCodeModel, ['debuggerModel'], 'Helios-Debugger');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "debuggerModel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@debuggerModel"];
+return $1;
+},
+args: [],
+source: "debuggerModel\x0a\x09^ debuggerModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "debuggerModel:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@debuggerModel"]=anObject;
+return self},
+args: ["anObject"],
+source: "debuggerModel: anObject\x0a\x09debuggerModel := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doIt:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $ErrorHandler(){return globals.ErrorHandler||(typeof ErrorHandler=="undefined"?nil:ErrorHandler)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._debuggerModel())._evaluate_(aString);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._tryCatch_((function(e){
+return smalltalk.withContext(function($ctx2) {
+_st($ErrorHandler())._handleError_(e);
+return nil;
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"doIt:",{aString:aString},globals.HLDebuggerCodeModel)})},
+args: ["aString"],
+source: "doIt: aString\x0a\x09^ [ self debuggerModel evaluate: aString ]\x0a\x09\x09tryCatch: [ :e | \x0a\x09\x09\x09ErrorHandler handleError: e.\x0a\x09\x09\x09nil ]",
+messageSends: ["tryCatch:", "evaluate:", "debuggerModel", "handleError:"],
+referencedClasses: ["ErrorHandler"]
+}),
+globals.HLDebuggerCodeModel);
+
+
+
+smalltalk.addClass('HLDebuggerCodeWidget', globals.HLBrowserCodeWidget, [], 'Helios-Debugger');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addStopAt:",
+protocol: 'actions',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@editor"])._setGutterMarker_gutter_value_(anInteger,"stops",_st(_st("<div class=\x22stop\x22></stop>"._asJQuery())._toArray())._first());
+return self}, function($ctx1) {$ctx1.fill(self,"addStopAt:",{anInteger:anInteger},globals.HLDebuggerCodeWidget)})},
+args: ["anInteger"],
+source: "addStopAt: anInteger\x0a\x09editor\x0a\x09\x09setGutterMarker: anInteger\x0a\x09\x09gutter: 'stops'\x0a\x09\x09value: '<div class=\x22stop\x22></stop>' asJQuery toArray first",
+messageSends: ["setGutterMarker:gutter:value:", "first", "toArray", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "clearHighlight",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._editor())._clearGutter_("stops");
+return self}, function($ctx1) {$ctx1.fill(self,"clearHighlight",{},globals.HLDebuggerCodeWidget)})},
+args: [],
+source: "clearHighlight\x0a\x09self editor clearGutter: 'stops'",
+messageSends: ["clearGutter:", "editor"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "contents:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._clearHighlight();
+($ctx1.supercall = true, globals.HLDebuggerCodeWidget.superclass.fn.prototype._contents_.apply(_st(self), [aString]));
+$ctx1.supercall = false;
+return self}, function($ctx1) {$ctx1.fill(self,"contents:",{aString:aString},globals.HLDebuggerCodeWidget)})},
+args: ["aString"],
+source: "contents: aString\x0a\x09self clearHighlight.\x0a\x09super contents: aString",
+messageSends: ["clearHighlight", "contents:"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "editorOptions",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=($ctx1.supercall = true, globals.HLDebuggerCodeWidget.superclass.fn.prototype._editorOptions.apply(_st(self), []));
+$ctx1.supercall = false;
+_st($2)._at_put_("gutters",["CodeMirror-linenumbers", "stops"]);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"editorOptions",{},globals.HLDebuggerCodeWidget)})},
+args: [],
+source: "editorOptions\x0a\x09^ super editorOptions\x0a\x09\x09at: 'gutters' put: #('CodeMirror-linenumbers' 'stops');\x0a\x09\x09yourself",
+messageSends: ["at:put:", "editorOptions", "yourself"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "highlight",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=_st(self._browserModel())._nextNode();
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+var node;
+node=$receiver;
+self._highlightNode_(node);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"highlight",{},globals.HLDebuggerCodeWidget)})},
+args: [],
+source: "highlight\x0a\x09self browserModel nextNode ifNotNil: [ :node |\x0a\x09\x09self highlightNode: node ]",
+messageSends: ["ifNotNil:", "nextNode", "browserModel", "highlightNode:"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "highlightNode:",
+protocol: 'actions',
+fn: function (aNode){
+var self=this;
+var token;
+return smalltalk.withContext(function($ctx1) { 
+var $4,$3,$2,$1,$5,$9,$8,$7,$11,$10,$6,$15,$14,$13,$12,$receiver;
+if(($receiver = aNode) == null || $receiver.isNil){
+aNode;
+} else {
+self._clearHighlight();
+$4=_st(aNode)._positionStart();
+$ctx1.sendIdx["positionStart"]=1;
+$3=_st($4)._x();
+$ctx1.sendIdx["x"]=1;
+$2=_st($3).__minus((1));
+$ctx1.sendIdx["-"]=1;
+$1=self._addStopAt_($2);
+$1;
+$5=self._editor();
+$9=_st(aNode)._positionStart();
+$ctx1.sendIdx["positionStart"]=2;
+$8=_st($9)._x();
+$ctx1.sendIdx["x"]=2;
+$7=_st($8).__minus((1));
+$ctx1.sendIdx["-"]=2;
+$11=_st(_st(aNode)._positionStart())._y();
+$ctx1.sendIdx["y"]=1;
+$10=_st($11).__minus((1));
+$ctx1.sendIdx["-"]=3;
+$6=globals.HashedCollection._newFromPairs_(["line",$7,"ch",$10]);
+$15=_st(aNode)._positionEnd();
+$ctx1.sendIdx["positionEnd"]=1;
+$14=_st($15)._x();
+$13=_st($14).__minus((1));
+$12=globals.HashedCollection._newFromPairs_(["line",$13,"ch",_st(_st(aNode)._positionEnd())._y()]);
+_st($5)._setSelection_to_($6,$12);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"highlightNode:",{aNode:aNode,token:token},globals.HLDebuggerCodeWidget)})},
+args: ["aNode"],
+source: "highlightNode: aNode\x0a\x09| token |\x0a\x09\x0a\x09aNode ifNotNil: [\x0a\x09\x09self\x0a\x09\x09\x09clearHighlight;\x0a\x09\x09\x09addStopAt: aNode positionStart x - 1.\x0a\x0a\x09\x09self editor \x0a\x09\x09\x09setSelection: #{ 'line' -> (aNode positionStart x - 1). 'ch' -> (aNode positionStart y - 1) }\x0a\x09\x09\x09to: #{ 'line' -> (aNode positionEnd x - 1). 'ch' -> (aNode positionEnd y) } ]",
+messageSends: ["ifNotNil:", "clearHighlight", "addStopAt:", "-", "x", "positionStart", "setSelection:to:", "editor", "y", "positionEnd"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeBrowserModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerWhere(){return globals.HLDebuggerWhere||(typeof HLDebuggerWhere=="undefined"?nil:HLDebuggerWhere)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$4,$3;
+($ctx1.supercall = true, globals.HLDebuggerCodeWidget.superclass.fn.prototype._observeBrowserModel.apply(_st(self), []));
+$ctx1.supercall = false;
+$2=self._browserModel();
+$ctx1.sendIdx["browserModel"]=1;
+$1=_st($2)._announcer();
+$ctx1.sendIdx["announcer"]=1;
+_st($1)._on_send_to_($HLDebuggerContextSelected(),"onContextSelected",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+$4=self._browserModel();
+$ctx1.sendIdx["browserModel"]=2;
+$3=_st($4)._announcer();
+$ctx1.sendIdx["announcer"]=2;
+_st($3)._on_send_to_($HLDebuggerStepped(),"onContextSelected",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st(_st(self._browserModel())._announcer())._on_send_to_($HLDebuggerWhere(),"onContextSelected",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeBrowserModel",{},globals.HLDebuggerCodeWidget)})},
+args: [],
+source: "observeBrowserModel\x0a\x09super observeBrowserModel.\x0a\x09\x0a\x09self browserModel announcer \x0a\x09\x09on: HLDebuggerContextSelected\x0a\x09\x09send: #onContextSelected\x0a\x09\x09to: self.\x0a\x09\x0a\x09self browserModel announcer \x0a\x09\x09on: HLDebuggerStepped\x0a\x09\x09send: #onContextSelected\x0a\x09\x09to: self.\x0a\x09\x0a\x09self browserModel announcer \x0a\x09\x09on: HLDebuggerWhere\x0a\x09\x09send: #onContextSelected\x0a\x09\x09to: self",
+messageSends: ["observeBrowserModel", "on:send:to:", "announcer", "browserModel"],
+referencedClasses: ["HLDebuggerContextSelected", "HLDebuggerStepped", "HLDebuggerWhere"]
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onContextSelected",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._highlight();
+return self}, function($ctx1) {$ctx1.fill(self,"onContextSelected",{},globals.HLDebuggerCodeWidget)})},
+args: [],
+source: "onContextSelected\x0a\x09self highlight",
+messageSends: ["highlight"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLDebuggerCodeWidget.superclass.fn.prototype._renderOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+self._contents_(_st(_st(self._browserModel())._selectedMethod())._source());
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLDebuggerCodeWidget)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09super renderOn: html.\x0a\x09self contents: self browserModel selectedMethod source",
+messageSends: ["renderOn:", "contents:", "source", "selectedMethod", "browserModel"],
+referencedClasses: []
+}),
+globals.HLDebuggerCodeWidget);
+
+
+
+smalltalk.addClass('HLDebuggerModel', globals.HLToolModel, ['rootContext', 'debugger', 'error'], 'Helios-Debugger');
+globals.HLDebuggerModel.comment="I am a model for debugging Amber code in Helios.\x0a\x0aMy instances hold a reference to an `ASTDebugger` instance, itself referencing the current `context`. The context should be the root of the context stack.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "atEnd",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._debugger())._atEnd();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"atEnd",{},globals.HLDebuggerModel)})},
+args: [],
+source: "atEnd\x0a\x09^ self debugger atEnd",
+messageSends: ["atEnd", "debugger"],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "contexts",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var contexts,context;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+contexts=_st($OrderedCollection())._new();
+context=self._rootContext();
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(context)._notNil();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._whileTrue_((function(){
+return smalltalk.withContext(function($ctx2) {
+_st(contexts)._add_(context);
+context=_st(context)._outerContext();
+return context;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$1=contexts;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"contexts",{contexts:contexts,context:context},globals.HLDebuggerModel)})},
+args: [],
+source: "contexts\x0a\x09| contexts context |\x0a\x09\x0a\x09contexts := OrderedCollection new.\x0a\x09context := self rootContext.\x0a\x09\x0a\x09[ context notNil ] whileTrue: [\x0a\x09\x09contexts add: context.\x0a\x09\x09context := context outerContext ].\x0a\x09\x09\x0a\x09^ contexts",
+messageSends: ["new", "rootContext", "whileTrue:", "notNil", "add:", "outerContext"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "currentContext",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._debugger())._context();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"currentContext",{},globals.HLDebuggerModel)})},
+args: [],
+source: "currentContext\x0a\x09^ self debugger context",
+messageSends: ["context", "debugger"],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "currentContext:",
+protocol: 'accessing',
+fn: function (aContext){
+var self=this;
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._selectedMethod_(_st(aContext)._method());
+_st(self._debugger())._context_(aContext);
+$ctx2.sendIdx["context:"]=1;
+$1=_st($HLDebuggerContextSelected())._new();
+_st($1)._context_(aContext);
+$2=_st($1)._yourself();
+return _st(self._announcer())._announce_($2);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"currentContext:",{aContext:aContext},globals.HLDebuggerModel)})},
+args: ["aContext"],
+source: "currentContext: aContext\x0a\x09self withChangesDo: [ \x0a\x09\x09self selectedMethod: aContext method.\x0a\x09\x09self debugger context: aContext.\x0a\x09\x09self announcer announce: (HLDebuggerContextSelected new\x0a\x09\x09\x09context: aContext;\x0a\x09\x09\x09yourself) ]",
+messageSends: ["withChangesDo:", "selectedMethod:", "method", "context:", "debugger", "announce:", "announcer", "new", "yourself"],
+referencedClasses: ["HLDebuggerContextSelected"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "debugger",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $ASTDebugger(){return globals.ASTDebugger||(typeof ASTDebugger=="undefined"?nil:ASTDebugger)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@debugger"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@debugger"]=_st($ASTDebugger())._new();
+$1=self["@debugger"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"debugger",{},globals.HLDebuggerModel)})},
+args: [],
+source: "debugger\x0a\x09^ debugger ifNil: [ debugger := ASTDebugger new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["ASTDebugger"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "error",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@error"];
+return $1;
+},
+args: [],
+source: "error\x0a\x09^ error",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "evaluate:",
+protocol: 'evaluating',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._evaluate_for_(aString,self._currentContext());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"evaluate:",{aString:aString},globals.HLDebuggerModel)})},
+args: ["aString"],
+source: "evaluate: aString\x0a\x09^ self environment \x0a\x09\x09evaluate: aString \x0a\x09\x09for: self currentContext",
+messageSends: ["evaluate:for:", "environment", "currentContext"],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "flushInnerContexts",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._currentContext();
+$ctx1.sendIdx["currentContext"]=1;
+_st($1)._innerContext_(nil);
+self["@rootContext"]=self._currentContext();
+self._initializeContexts();
+return self}, function($ctx1) {$ctx1.fill(self,"flushInnerContexts",{},globals.HLDebuggerModel)})},
+args: [],
+source: "flushInnerContexts\x0a\x09\x22When stepping, the inner contexts are not relevent anymore,\x0a\x09and can be flushed\x22\x0a\x09\x0a\x09self currentContext innerContext: nil.\x0a\x09rootContext := self currentContext.\x0a\x09self initializeContexts",
+messageSends: ["innerContext:", "currentContext", "initializeContexts"],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeFromError:",
+protocol: 'initialization',
+fn: function (anError){
+var self=this;
+var errorContext;
+function $AIContext(){return globals.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
+return smalltalk.withContext(function($ctx1) { 
+self["@error"]=anError;
+errorContext=_st($AIContext())._fromMethodContext_(_st(self["@error"])._context());
+self["@rootContext"]=_st(self["@error"])._signalerContextFrom_(errorContext);
+self._selectedMethod_(_st(self["@rootContext"])._method());
+return self}, function($ctx1) {$ctx1.fill(self,"initializeFromError:",{anError:anError,errorContext:errorContext},globals.HLDebuggerModel)})},
+args: ["anError"],
+source: "initializeFromError: anError\x0a\x09| errorContext |\x0a\x09\x0a\x09error := anError.\x0a\x09errorContext := (AIContext fromMethodContext: error context).\x0a\x09rootContext := error signalerContextFrom: errorContext.\x0a\x09self selectedMethod: rootContext method",
+messageSends: ["fromMethodContext:", "context", "signalerContextFrom:", "selectedMethod:", "method"],
+referencedClasses: ["AIContext"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "nextNode",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._debugger())._node();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"nextNode",{},globals.HLDebuggerModel)})},
+args: [],
+source: "nextNode\x0a\x09^ self debugger node",
+messageSends: ["node", "debugger"],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onStep",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$4;
+self["@rootContext"]=self._currentContext();
+$ctx1.sendIdx["currentContext"]=1;
+$2=self._currentContext();
+$ctx1.sendIdx["currentContext"]=2;
+$1=_st($2)._method();
+self._selectedMethod_($1);
+$3=_st($HLDebuggerContextSelected())._new();
+_st($3)._context_(self._currentContext());
+$4=_st($3)._yourself();
+_st(self._announcer())._announce_($4);
+return self}, function($ctx1) {$ctx1.fill(self,"onStep",{},globals.HLDebuggerModel)})},
+args: [],
+source: "onStep\x0a\x09rootContext := self currentContext.\x0a\x09\x0a\x09\x22Force a refresh of the context list and code widget\x22\x0a\x09self selectedMethod: self currentContext method.\x0a\x09self announcer announce: (HLDebuggerContextSelected new\x0a\x09\x09context: self currentContext;\x0a\x09\x09yourself)",
+messageSends: ["currentContext", "selectedMethod:", "method", "announce:", "announcer", "context:", "new", "yourself"],
+referencedClasses: ["HLDebuggerContextSelected"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "proceed",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerProceeded(){return globals.HLDebuggerProceeded||(typeof HLDebuggerProceeded=="undefined"?nil:HLDebuggerProceeded)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._debugger())._proceed();
+_st(self._announcer())._announce_(_st($HLDebuggerProceeded())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"proceed",{},globals.HLDebuggerModel)})},
+args: [],
+source: "proceed\x0a\x09self debugger proceed.\x0a\x09\x0a\x09self announcer announce: HLDebuggerProceeded new",
+messageSends: ["proceed", "debugger", "announce:", "announcer", "new"],
+referencedClasses: ["HLDebuggerProceeded"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "restart",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st(self._debugger())._restart();
+self._onStep();
+$1=_st($HLDebuggerStepped())._new();
+_st($1)._context_(self._currentContext());
+$2=_st($1)._yourself();
+_st(self._announcer())._announce_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"restart",{},globals.HLDebuggerModel)})},
+args: [],
+source: "restart\x0a\x09self debugger restart.\x0a\x09self onStep.\x0a\x09\x0a\x09self announcer announce: (HLDebuggerStepped new\x0a\x09\x09context: self currentContext;\x0a\x09\x09yourself)",
+messageSends: ["restart", "debugger", "onStep", "announce:", "announcer", "context:", "new", "currentContext", "yourself"],
+referencedClasses: ["HLDebuggerStepped"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "rootContext",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@rootContext"];
+return $1;
+},
+args: [],
+source: "rootContext\x0a\x09^ rootContext",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "stepOver",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st(self._debugger())._stepOver();
+self._onStep();
+$1=_st($HLDebuggerStepped())._new();
+_st($1)._context_(self._currentContext());
+$2=_st($1)._yourself();
+_st(self._announcer())._announce_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},globals.HLDebuggerModel)})},
+args: [],
+source: "stepOver\x0a\x09self debugger stepOver.\x0a\x09self onStep.\x0a\x09\x0a\x09self announcer announce: (HLDebuggerStepped new\x0a\x09\x09context: self currentContext;\x0a\x09\x09yourself)",
+messageSends: ["stepOver", "debugger", "onStep", "announce:", "announcer", "context:", "new", "currentContext", "yourself"],
+referencedClasses: ["HLDebuggerStepped"]
+}),
+globals.HLDebuggerModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "where",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerWhere(){return globals.HLDebuggerWhere||(typeof HLDebuggerWhere=="undefined"?nil:HLDebuggerWhere)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLDebuggerWhere())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"where",{},globals.HLDebuggerModel)})},
+args: [],
+source: "where\x0a\x09self announcer announce: HLDebuggerWhere new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLDebuggerWhere"]
+}),
+globals.HLDebuggerModel);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (anError){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._initializeFromError_(anError);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anError:anError},globals.HLDebuggerModel.klass)})},
+args: ["anError"],
+source: "on: anError\x0a\x09^ self new\x0a\x09\x09initializeFromError: anError;\x0a\x09\x09yourself",
+messageSends: ["initializeFromError:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLDebuggerModel.klass);
+
+
+smalltalk.addClass('HLErrorHandler', globals.Object, [], 'Helios-Debugger');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "confirmDebugError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+function $HLConfirmationWidget(){return globals.HLConfirmationWidget||(typeof HLConfirmationWidget=="undefined"?nil:HLConfirmationWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLConfirmationWidget())._new();
+_st($1)._confirmationString_(_st(anError)._messageText());
+_st($1)._actionBlock_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._debugError_(anError);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+_st($1)._cancelButtonLabel_("Abandon");
+_st($1)._confirmButtonLabel_("Debug");
+$2=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"confirmDebugError:",{anError:anError},globals.HLErrorHandler)})},
+args: ["anError"],
+source: "confirmDebugError: anError\x0a\x09HLConfirmationWidget new\x0a\x09\x09confirmationString: anError messageText;\x0a\x09\x09actionBlock: [ self debugError: anError ];\x0a\x09\x09cancelButtonLabel: 'Abandon';\x0a\x09\x09confirmButtonLabel: 'Debug';\x0a\x09\x09show",
+messageSends: ["confirmationString:", "new", "messageText", "actionBlock:", "debugError:", "cancelButtonLabel:", "confirmButtonLabel:", "show"],
+referencedClasses: ["HLConfirmationWidget"]
+}),
+globals.HLErrorHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "debugError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+function $HLDebugger(){return globals.HLDebugger||(typeof HLDebugger=="undefined"?nil:HLDebugger)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+function $ConsoleErrorHandler(){return globals.ConsoleErrorHandler||(typeof ConsoleErrorHandler=="undefined"?nil:ConsoleErrorHandler)}
+return smalltalk.withContext(function($ctx1) { 
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st($HLDebugger())._on_(anError))._openAsTab();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._on_do_($Error(),(function(error){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st($ConsoleErrorHandler())._new())._handleError_(error);
+}, function($ctx2) {$ctx2.fillBlock({error:error},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"debugError:",{anError:anError},globals.HLErrorHandler)})},
+args: ["anError"],
+source: "debugError: anError\x0a\x0a\x09[ \x0a\x09\x09(HLDebugger on: anError) openAsTab \x0a\x09] \x0a\x09\x09on: Error \x0a\x09\x09do: [ :error | ConsoleErrorHandler new handleError: error ]",
+messageSends: ["on:do:", "openAsTab", "on:", "handleError:", "new"],
+referencedClasses: ["HLDebugger", "Error", "ConsoleErrorHandler"]
+}),
+globals.HLErrorHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleError:",
+protocol: 'error handling',
+fn: function (anError){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._confirmDebugError_(anError);
+return self}, function($ctx1) {$ctx1.fill(self,"handleError:",{anError:anError},globals.HLErrorHandler)})},
+args: ["anError"],
+source: "handleError: anError\x0a\x09self confirmDebugError: anError",
+messageSends: ["confirmDebugError:"],
+referencedClasses: []
+}),
+globals.HLErrorHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onErrorHandled",
+protocol: 'error handling',
+fn: function (){
+var self=this;
+function $HLProgressWidget(){return globals.HLProgressWidget||(typeof HLProgressWidget=="undefined"?nil:HLProgressWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLProgressWidget())._default();
+_st($1)._flush();
+$2=_st($1)._remove();
+return self}, function($ctx1) {$ctx1.fill(self,"onErrorHandled",{},globals.HLErrorHandler)})},
+args: [],
+source: "onErrorHandled\x0a\x09\x22when an error is handled, we need to make sure that\x0a\x09any progress bar widget gets removed. Because HLProgressBarWidget is asynchronous,\x0a\x09it has to be done here.\x22\x0a\x09\x0a\x09HLProgressWidget default \x0a\x09\x09flush; \x0a\x09\x09remove",
+messageSends: ["flush", "default", "remove"],
+referencedClasses: ["HLProgressWidget"]
+}),
+globals.HLErrorHandler);
+
+
+
+smalltalk.addClass('HLStackListWidget', globals.HLToolListWidget, [], 'Helios-Debugger');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "items",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._contexts();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"items",{},globals.HLStackListWidget)})},
+args: [],
+source: "items\x0a\x09^ self model contexts",
+messageSends: ["contexts", "model"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Call stack";
+},
+args: [],
+source: "label\x0a\x09^ 'Call stack'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLStackListWidget.superclass.fn.prototype._observeModel.apply(_st(self), []));
+$ctx1.supercall = false;
+_st(_st(self._model())._announcer())._on_send_to_($HLDebuggerStepped(),"onDebuggerStepped:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLStackListWidget)})},
+args: [],
+source: "observeModel\x0a\x09super observeModel.\x0a\x09\x0a\x09self model announcer \x0a\x09\x09on: HLDebuggerStepped\x0a\x09\x09send: #onDebuggerStepped:\x0a\x09\x09to: self",
+messageSends: ["observeModel", "on:send:to:", "announcer", "model"],
+referencedClasses: ["HLDebuggerStepped"]
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onDebuggerStepped:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@items"]=nil;
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onDebuggerStepped:",{anAnnouncement:anAnnouncement},globals.HLStackListWidget)})},
+args: ["anAnnouncement"],
+source: "onDebuggerStepped: anAnnouncement\x0a\x09items := nil.\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "proceed",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._proceed();
+return self}, function($ctx1) {$ctx1.fill(self,"proceed",{},globals.HLStackListWidget)})},
+args: [],
+source: "proceed\x0a\x09self model proceed",
+messageSends: ["proceed", "model"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$5,$6,$7,$8,$9,$10,$2;
+$1=_st(html)._div();
+_st($1)._class_("debugger_bar");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._button();
+$ctx2.sendIdx["button"]=1;
+_st($3)._class_("btn restart");
+$ctx2.sendIdx["class:"]=2;
+_st($3)._with_("Restart");
+$ctx2.sendIdx["with:"]=2;
+$4=_st($3)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._restart();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+$ctx2.sendIdx["onClick:"]=1;
+$4;
+$5=_st(html)._button();
+$ctx2.sendIdx["button"]=2;
+_st($5)._class_("btn where");
+$ctx2.sendIdx["class:"]=3;
+_st($5)._with_("Where");
+$ctx2.sendIdx["with:"]=3;
+$6=_st($5)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._where();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+$ctx2.sendIdx["onClick:"]=2;
+$6;
+$7=_st(html)._button();
+$ctx2.sendIdx["button"]=3;
+_st($7)._class_("btn stepOver");
+$ctx2.sendIdx["class:"]=4;
+_st($7)._with_("Step over");
+$ctx2.sendIdx["with:"]=4;
+$8=_st($7)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._stepOver();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
+$ctx2.sendIdx["onClick:"]=3;
+$8;
+$9=_st(html)._button();
+_st($9)._class_("btn proceed");
+_st($9)._with_("Proceed");
+$10=_st($9)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._proceed();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,5)})}));
+return $10;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},globals.HLStackListWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09html div \x0a\x09\x09class: 'debugger_bar'; \x0a\x09\x09with: [\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn restart';\x0a\x09\x09\x09\x09with: 'Restart';\x0a\x09\x09\x09\x09onClick: [ self restart ].\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn where';\x0a\x09\x09\x09\x09with: 'Where';\x0a\x09\x09\x09\x09onClick: [ self where ].\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn stepOver';\x0a\x09\x09\x09\x09with: 'Step over';\x0a\x09\x09\x09\x09onClick: [ self stepOver ].\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn proceed';\x0a\x09\x09\x09\x09with: 'Proceed';\x0a\x09\x09\x09\x09onClick: [ self proceed ] ]",
+messageSends: ["class:", "div", "with:", "button", "onClick:", "restart", "where", "stepOver", "proceed"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "restart",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._restart();
+return self}, function($ctx1) {$ctx1.fill(self,"restart",{},globals.HLStackListWidget)})},
+args: [],
+source: "restart\x0a\x09self model restart",
+messageSends: ["restart", "model"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aContext){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._currentContext_(aContext);
+($ctx1.supercall = true, globals.HLStackListWidget.superclass.fn.prototype._selectItem_.apply(_st(self), [aContext]));
+$ctx1.supercall = false;
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aContext:aContext},globals.HLStackListWidget)})},
+args: ["aContext"],
+source: "selectItem: aContext\x0a   \x09self model currentContext: aContext.\x0a\x09super selectItem: aContext",
+messageSends: ["currentContext:", "model", "selectItem:"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedItem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._currentContext();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedItem",{},globals.HLStackListWidget)})},
+args: [],
+source: "selectedItem\x0a   \x09^ self model currentContext",
+messageSends: ["currentContext", "model"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "stepOver",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._stepOver();
+return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},globals.HLStackListWidget)})},
+args: [],
+source: "stepOver\x0a\x09self model stepOver",
+messageSends: ["stepOver", "model"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "where",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._where();
+return self}, function($ctx1) {$ctx1.fill(self,"where",{},globals.HLStackListWidget)})},
+args: [],
+source: "where\x0a\x09self model where",
+messageSends: ["where", "model"],
+referencedClasses: []
+}),
+globals.HLStackListWidget);
+
+
+});

src/Helios-Debugger.st

@@ -0,0 +1,543 @@
+Smalltalk createPackage: 'Helios-Debugger'!
+Object subclass: #HLContextInspectorDecorator
+	instanceVariableNames: 'context'
+	package: 'Helios-Debugger'!
+
+!HLContextInspectorDecorator methodsFor: 'accessing'!
+
+context
+	^ context
+! !
+
+!HLContextInspectorDecorator methodsFor: 'evaluating'!
+
+evaluate: aString on: anEvaluator
+	^ self context evaluate: aString on: anEvaluator
+! !
+
+!HLContextInspectorDecorator methodsFor: 'initialization'!
+
+initializeFromContext: aContext
+	context := aContext
+! !
+
+!HLContextInspectorDecorator methodsFor: 'inspecting'!
+
+inspectOn: anInspector
+	| variables inspectedContext |
+	
+	variables := Dictionary new.
+	inspectedContext := self context.
+	
+	variables addAll: inspectedContext locals.
+	
+	[ inspectedContext notNil and: [ inspectedContext isBlockContext ] ] whileTrue: [
+		inspectedContext := inspectedContext outerContext.
+		inspectedContext ifNotNil: [
+			variables addAll: inspectedContext locals ] ].
+	
+	anInspector
+		setLabel: 'Context';
+		setVariables: variables
+! !
+
+!HLContextInspectorDecorator class methodsFor: 'instance creation'!
+
+on: aContext
+	^ self new
+		initializeFromContext: aContext;
+		yourself
+! !
+
+HLFocusableWidget subclass: #HLDebugger
+	instanceVariableNames: 'model stackListWidget codeWidget inspectorWidget'
+	package: 'Helios-Debugger'!
+!HLDebugger commentStamp!
+I am the main widget for the Helios debugger.!
+
+!HLDebugger methodsFor: 'accessing'!
+
+cssClass
+	^ super cssClass, ' hl_debugger'
+!
+
+model
+	^ model ifNil: [ model := HLDebuggerModel new ]
+! !
+
+!HLDebugger methodsFor: 'actions'!
+
+focus
+	self stackListWidget focus
+!
+
+observeModel
+	self model announcer 
+		on: HLDebuggerContextSelected
+		send: #onContextSelected:
+		to: self;
+		
+		on: HLDebuggerStepped
+		send: #onDebuggerStepped:
+		to: self;
+		
+		on: HLDebuggerProceeded
+		send: #onDebuggerProceeded
+		to: self
+!
+
+unregister
+	super unregister.
+	self inspectorWidget unregister
+! !
+
+!HLDebugger methodsFor: 'initialization'!
+
+initializeFromError: anError
+	model := HLDebuggerModel on: anError.
+	self observeModel
+! !
+
+!HLDebugger methodsFor: 'keybindings'!
+
+registerBindingsOn: aBindingGroup
+	HLToolCommand 
+		registerConcreteClassesOn: aBindingGroup 
+		for: self model
+! !
+
+!HLDebugger methodsFor: 'reactions'!
+
+onContextSelected: anAnnouncement
+	self inspectorWidget inspect: (HLContextInspectorDecorator on: anAnnouncement context)
+!
+
+onDebuggerProceeded
+	self removeTab
+!
+
+onDebuggerStepped: anAnnouncement
+	self model atEnd ifTrue: [ self removeTab ].
+	
+	self inspectorWidget inspect: (HLContextInspectorDecorator on: anAnnouncement context).
+	self stackListWidget refresh
+! !
+
+!HLDebugger methodsFor: 'rendering'!
+
+renderContentOn: html
+	self renderHeadOn: html.
+	html with: (HLContainer with: (HLVerticalSplitter
+		with: self codeWidget
+		with: (HLHorizontalSplitter
+			with: self stackListWidget
+			with: self inspectorWidget)))
+!
+
+renderHeadOn: html
+	html div 
+		class: 'head'; 
+		with: [ html h2 with: self model error messageText ]
+! !
+
+!HLDebugger methodsFor: 'widgets'!
+
+codeWidget
+	^ codeWidget ifNil: [ codeWidget := HLDebuggerCodeWidget new
+		model: (HLDebuggerCodeModel new
+			debuggerModel: self model;
+			yourself);
+		browserModel: self model;
+		yourself ]
+!
+
+inspectorWidget
+	^ inspectorWidget ifNil: [ 
+		inspectorWidget := HLInspectorWidget new ]
+!
+
+stackListWidget
+	^ stackListWidget ifNil: [ 
+		stackListWidget := (HLStackListWidget on: self model)
+			next: self codeWidget;
+			yourself ]
+! !
+
+!HLDebugger class methodsFor: 'accessing'!
+
+tabClass
+	^ 'debugger'
+!
+
+tabLabel
+	^ 'Debugger'
+! !
+
+!HLDebugger class methodsFor: 'instance creation'!
+
+on: anError
+	^ self new
+		initializeFromError: anError;
+		yourself
+! !
+
+HLCodeModel subclass: #HLDebuggerCodeModel
+	instanceVariableNames: 'debuggerModel'
+	package: 'Helios-Debugger'!
+
+!HLDebuggerCodeModel methodsFor: 'accessing'!
+
+debuggerModel
+	^ debuggerModel
+!
+
+debuggerModel: anObject
+	debuggerModel := anObject
+! !
+
+!HLDebuggerCodeModel methodsFor: 'actions'!
+
+doIt: aString
+	^ [ self debuggerModel evaluate: aString ]
+		tryCatch: [ :e | 
+			ErrorHandler handleError: e.
+			nil ]
+! !
+
+HLBrowserCodeWidget subclass: #HLDebuggerCodeWidget
+	instanceVariableNames: ''
+	package: 'Helios-Debugger'!
+
+!HLDebuggerCodeWidget methodsFor: 'accessing'!
+
+contents: aString
+	self clearHighlight.
+	super contents: aString
+!
+
+editorOptions
+	^ super editorOptions
+		at: 'gutters' put: #('CodeMirror-linenumbers' 'stops');
+		yourself
+! !
+
+!HLDebuggerCodeWidget methodsFor: 'actions'!
+
+addStopAt: anInteger
+	editor
+		setGutterMarker: anInteger
+		gutter: 'stops'
+		value: '<div class="stop"></stop>' asJQuery toArray first
+!
+
+clearHighlight
+	self editor clearGutter: 'stops'
+!
+
+highlight
+	self browserModel nextNode ifNotNil: [ :node |
+		self highlightNode: node ]
+!
+
+highlightNode: aNode
+	| token |
+	
+	aNode ifNotNil: [
+		self
+			clearHighlight;
+			addStopAt: aNode positionStart x - 1.
+
+		self editor 
+			setSelection: #{ 'line' -> (aNode positionStart x - 1). 'ch' -> (aNode positionStart y - 1) }
+			to: #{ 'line' -> (aNode positionEnd x - 1). 'ch' -> (aNode positionEnd y) } ]
+!
+
+observeBrowserModel
+	super observeBrowserModel.
+	
+	self browserModel announcer 
+		on: HLDebuggerContextSelected
+		send: #onContextSelected
+		to: self.
+	
+	self browserModel announcer 
+		on: HLDebuggerStepped
+		send: #onContextSelected
+		to: self.
+	
+	self browserModel announcer 
+		on: HLDebuggerWhere
+		send: #onContextSelected
+		to: self
+! !
+
+!HLDebuggerCodeWidget methodsFor: 'reactions'!
+
+onContextSelected
+	self highlight
+! !
+
+!HLDebuggerCodeWidget methodsFor: 'rendering'!
+
+renderOn: html
+	super renderOn: html.
+	self contents: self browserModel selectedMethod source
+! !
+
+HLToolModel subclass: #HLDebuggerModel
+	instanceVariableNames: 'rootContext debugger error'
+	package: 'Helios-Debugger'!
+!HLDebuggerModel commentStamp!
+I am a model for debugging Amber code in Helios.
+
+My instances hold a reference to an `ASTDebugger` instance, itself referencing the current `context`. The context should be the root of the context stack.!
+
+!HLDebuggerModel methodsFor: 'accessing'!
+
+contexts
+	| contexts context |
+	
+	contexts := OrderedCollection new.
+	context := self rootContext.
+	
+	[ context notNil ] whileTrue: [
+		contexts add: context.
+		context := context outerContext ].
+		
+	^ contexts
+!
+
+currentContext
+	^ self debugger context
+!
+
+currentContext: aContext
+	self withChangesDo: [ 
+		self selectedMethod: aContext method.
+		self debugger context: aContext.
+		self announcer announce: (HLDebuggerContextSelected new
+			context: aContext;
+			yourself) ]
+!
+
+debugger
+	^ debugger ifNil: [ debugger := ASTDebugger new ]
+!
+
+error
+	^ error
+!
+
+nextNode
+	^ self debugger node
+!
+
+rootContext
+	^ rootContext
+! !
+
+!HLDebuggerModel methodsFor: 'actions'!
+
+proceed
+	self debugger proceed.
+	
+	self announcer announce: HLDebuggerProceeded new
+!
+
+restart
+	self debugger restart.
+	self onStep.
+	
+	self announcer announce: (HLDebuggerStepped new
+		context: self currentContext;
+		yourself)
+!
+
+stepOver
+	self debugger stepOver.
+	self onStep.
+	
+	self announcer announce: (HLDebuggerStepped new
+		context: self currentContext;
+		yourself)
+!
+
+where
+	self announcer announce: HLDebuggerWhere new
+! !
+
+!HLDebuggerModel methodsFor: 'evaluating'!
+
+evaluate: aString
+	^ self environment 
+		evaluate: aString 
+		for: self currentContext
+! !
+
+!HLDebuggerModel methodsFor: 'initialization'!
+
+initializeFromError: anError
+	| errorContext |
+	
+	error := anError.
+	errorContext := (AIContext fromMethodContext: error context).
+	rootContext := error signalerContextFrom: errorContext.
+	self selectedMethod: rootContext method
+! !
+
+!HLDebuggerModel methodsFor: 'private'!
+
+flushInnerContexts
+	"When stepping, the inner contexts are not relevent anymore,
+	and can be flushed"
+	
+	self currentContext innerContext: nil.
+	rootContext := self currentContext.
+	self initializeContexts
+! !
+
+!HLDebuggerModel methodsFor: 'reactions'!
+
+onStep
+	rootContext := self currentContext.
+	
+	"Force a refresh of the context list and code widget"
+	self selectedMethod: self currentContext method.
+	self announcer announce: (HLDebuggerContextSelected new
+		context: self currentContext;
+		yourself)
+! !
+
+!HLDebuggerModel methodsFor: 'testing'!
+
+atEnd
+	^ self debugger atEnd
+! !
+
+!HLDebuggerModel class methodsFor: 'instance creation'!
+
+on: anError
+	^ self new
+		initializeFromError: anError;
+		yourself
+! !
+
+Object subclass: #HLErrorHandler
+	instanceVariableNames: ''
+	package: 'Helios-Debugger'!
+
+!HLErrorHandler methodsFor: 'error handling'!
+
+confirmDebugError: anError
+	HLConfirmationWidget new
+		confirmationString: anError messageText;
+		actionBlock: [ self debugError: anError ];
+		cancelButtonLabel: 'Abandon';
+		confirmButtonLabel: 'Debug';
+		show
+!
+
+debugError: anError
+
+	[ 
+		(HLDebugger on: anError) openAsTab 
+	] 
+		on: Error 
+		do: [ :error | ConsoleErrorHandler new handleError: error ]
+!
+
+handleError: anError
+	self confirmDebugError: anError
+!
+
+onErrorHandled
+	"when an error is handled, we need to make sure that
+	any progress bar widget gets removed. Because HLProgressBarWidget is asynchronous,
+	it has to be done here."
+	
+	HLProgressWidget default 
+		flush; 
+		remove
+! !
+
+HLToolListWidget subclass: #HLStackListWidget
+	instanceVariableNames: ''
+	package: 'Helios-Debugger'!
+
+!HLStackListWidget methodsFor: 'accessing'!
+
+items
+	^ self model contexts
+!
+
+label
+	^ 'Call stack'
+! !
+
+!HLStackListWidget methodsFor: 'actions'!
+
+observeModel
+	super observeModel.
+	
+	self model announcer 
+		on: HLDebuggerStepped
+		send: #onDebuggerStepped:
+		to: self
+!
+
+proceed
+	self model proceed
+!
+
+restart
+	self model restart
+!
+
+selectItem: aContext
+   	self model currentContext: aContext.
+	super selectItem: aContext
+!
+
+selectedItem
+   	^ self model currentContext
+!
+
+stepOver
+	self model stepOver
+!
+
+where
+	self model where
+! !
+
+!HLStackListWidget methodsFor: 'reactions'!
+
+onDebuggerStepped: anAnnouncement
+	items := nil.
+	self refresh
+! !
+
+!HLStackListWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	html div 
+		class: 'debugger_bar'; 
+		with: [
+			html button 
+				class: 'btn restart';
+				with: 'Restart';
+				onClick: [ self restart ].
+			html button 
+				class: 'btn where';
+				with: 'Where';
+				onClick: [ self where ].
+			html button 
+				class: 'btn stepOver';
+				with: 'Step over';
+				onClick: [ self stepOver ].
+			html button 
+				class: 'btn proceed';
+				with: 'Proceed';
+				onClick: [ self proceed ] ]
+! !
+

src/Helios-Exceptions.js

@@ -0,0 +1,16 @@
+define("helios/Helios-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Exceptions');
+smalltalk.packages["Helios-Exceptions"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLError', globals.Error, [], 'Helios-Exceptions');
+globals.HLError.comment="I am the abstract superclass of all Helios-specific errors.";
+
+
+smalltalk.addClass('HLChangeForbidden', globals.HLError, [], 'Helios-Exceptions');
+globals.HLChangeForbidden.comment="I get signaled when a (often user) requested change is forbidden. A confirmation message can then be displayed to the user.\x0a\x0aSee `HLModel >> withChangesDo:`.";
+
+
+smalltalk.addClass('HLListItemNotFound', globals.HLError, [], 'Helios-Exceptions');
+globals.HLListItemNotFound.comment="I get signaled by a `HLListWidget` when a non-existing item in the list is activated.";
+
+});

src/Helios-Exceptions.st

@@ -0,0 +1,21 @@
+Smalltalk createPackage: 'Helios-Exceptions'!
+Error subclass: #HLError
+	instanceVariableNames: ''
+	package: 'Helios-Exceptions'!
+!HLError commentStamp!
+I am the abstract superclass of all Helios-specific errors.!
+
+HLError subclass: #HLChangeForbidden
+	instanceVariableNames: ''
+	package: 'Helios-Exceptions'!
+!HLChangeForbidden commentStamp!
+I get signaled when a (often user) requested change is forbidden. A confirmation message can then be displayed to the user.
+
+See `HLModel >> withChangesDo:`.!
+
+HLError subclass: #HLListItemNotFound
+	instanceVariableNames: ''
+	package: 'Helios-Exceptions'!
+!HLListItemNotFound commentStamp!
+I get signaled by a `HLListWidget` when a non-existing item in the list is activated.!
+

src/Helios-Helpers.js

@@ -0,0 +1,1221 @@
+define("helios/Helios-Helpers", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Helpers');
+smalltalk.packages["Helios-Helpers"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLClassifier', globals.Object, ['next', 'method'], 'Helios-Helpers');
+globals.HLClassifier.comment="I am an abstract class implementing a link in a `chain of responsibility` pattern.\x0a\x0aSubclasses are in charge of classifying a method according to multiple strategies.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classify",
+protocol: 'protocol',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$receiver;
+$1=self._next();
+$ctx1.sendIdx["next"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+return false;
+} else {
+$1;
+};
+$3=self._doClassify();
+if(smalltalk.assert($3)){
+$2=true;
+} else {
+$2=_st(self._next())._classify();
+};
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"classify",{},globals.HLClassifier)})},
+args: [],
+source: "classify\x0a\x09self next ifNil: [ ^ false ].\x0a\x09\x0a\x09^ self doClassify\x0a\x09\x09ifTrue: [ true ]\x0a\x09\x09ifFalse: [ self next classify ]",
+messageSends: ["ifNil:", "next", "ifTrue:ifFalse:", "doClassify", "classify"],
+referencedClasses: []
+}),
+globals.HLClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doClassify",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._subclassResponsibility();
+return self}, function($ctx1) {$ctx1.fill(self,"doClassify",{},globals.HLClassifier)})},
+args: [],
+source: "doClassify\x0a\x09self subclassResponsibility",
+messageSends: ["subclassResponsibility"],
+referencedClasses: []
+}),
+globals.HLClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "method",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@method"];
+return $1;
+},
+args: [],
+source: "method\x0a\x09^ method",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "method:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+self["@method"]=anObject;
+$1=self._next();
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+var nextLink;
+nextLink=$receiver;
+_st(nextLink)._method_(anObject);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"method:",{anObject:anObject},globals.HLClassifier)})},
+args: ["anObject"],
+source: "method: anObject\x0a\x09method := anObject.\x0a\x09self next\x0a\x09\x09ifNotNil: [ :nextLink | nextLink method: anObject ]",
+messageSends: ["ifNotNil:", "next", "method:"],
+referencedClasses: []
+}),
+globals.HLClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "next",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@next"];
+return $1;
+},
+args: [],
+source: "next\x0a\x09^ next",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "next:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@next"]=anObject;
+return self},
+args: ["anObject"],
+source: "next: anObject\x0a\x09next := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassifier);
+
+
+
+smalltalk.addClass('HLAccessorClassifier', globals.HLClassifier, [], 'Helios-Helpers');
+globals.HLAccessorClassifier.comment="I am a classifier checking the method selector matches an instance variable name.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doClassify",
+protocol: 'private',
+fn: function (){
+var self=this;
+var names,selector;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+names=_st(_st(self["@method"])._methodClass())._allInstanceVariableNames();
+selector=_st(self["@method"])._selector();
+$1=_st(_st(selector)._last()).__eq(":");
+if(smalltalk.assert($1)){
+selector=_st(selector)._allButLast();
+selector;
+};
+$2=_st(names)._includes_(selector);
+if(! smalltalk.assert($2)){
+return false;
+};
+_st(self["@method"])._protocol_("accessing");
+return true;
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{names:names,selector:selector},globals.HLAccessorClassifier)})},
+args: [],
+source: "doClassify\x0a\x09| names selector |\x0a\x09\x0a\x09names := method methodClass allInstanceVariableNames.\x0a\x09selector := method selector.\x0a\x09\x0a\x09(selector last = ':')\x0a\x09\x09ifTrue: [ \x22selector might be a setter\x22\x0a\x09\x09\x09selector := selector allButLast ].\x0a\x09\x0a\x09(names includes: selector)\x0a\x09\x09ifFalse: [ ^ false ].\x0a\x09\x09\x0a\x09method protocol: 'accessing'.\x0a\x09^ true.",
+messageSends: ["allInstanceVariableNames", "methodClass", "selector", "ifTrue:", "=", "last", "allButLast", "ifFalse:", "includes:", "protocol:"],
+referencedClasses: []
+}),
+globals.HLAccessorClassifier);
+
+
+
+smalltalk.addClass('HLImplementorClassifier', globals.HLClassifier, [], 'Helios-Helpers');
+globals.HLImplementorClassifier.comment="I am a classifier checking the other implementations of the same selector and choose the protocol the most populated.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doClassify",
+protocol: 'private',
+fn: function (){
+var self=this;
+var currentClass;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$2;
+var $early={};
+try {
+currentClass=_st(self["@method"])._methodClass();
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(currentClass)._superclass();
+$ctx2.sendIdx["superclass"]=1;
+return _st($1)._isNil();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._whileFalse_((function(){
+return smalltalk.withContext(function($ctx2) {
+currentClass=_st(currentClass)._superclass();
+currentClass;
+$3=currentClass;
+$4=_st(self["@method"])._selector();
+$ctx2.sendIdx["selector"]=1;
+$2=_st($3)._includesSelector_($4);
+if(smalltalk.assert($2)){
+_st(self["@method"])._protocol_(_st(_st(currentClass).__gt_gt(_st(self["@method"])._selector()))._protocol());
+throw $early=[true];
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return false;
+}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{currentClass:currentClass},globals.HLImplementorClassifier)})},
+args: [],
+source: "doClassify\x0a\x09| currentClass |\x0a\x09currentClass := method methodClass.\x0a\x09\x0a\x09[ currentClass superclass isNil ] whileFalse: [\x0a\x09\x09currentClass := currentClass superclass.\x0a\x09\x09(currentClass includesSelector: method selector)\x0a\x09\x09\x09ifTrue: [ \x0a\x09\x09\x09\x09method protocol: (currentClass >> method selector) protocol.\x0a\x09\x09\x09\x09^ true ]].\x0a\x09\x0a\x09^ false.",
+messageSends: ["methodClass", "whileFalse:", "isNil", "superclass", "ifTrue:", "includesSelector:", "selector", "protocol:", "protocol", ">>"],
+referencedClasses: []
+}),
+globals.HLImplementorClassifier);
+
+
+
+smalltalk.addClass('HLPrefixClassifier', globals.HLClassifier, ['prefixMapping'], 'Helios-Helpers');
+globals.HLPrefixClassifier.comment="I am classifier checking the method selector to know if it begins with a known prefix.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "buildPrefixDictionary",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+self["@prefixMapping"]=_st($Dictionary())._new();
+$1=self["@prefixMapping"];
+_st($1)._at_put_("test","tests");
+$ctx1.sendIdx["at:put:"]=1;
+_st($1)._at_put_("bench","benchmarking");
+$ctx1.sendIdx["at:put:"]=2;
+_st($1)._at_put_("copy","copying");
+$ctx1.sendIdx["at:put:"]=3;
+_st($1)._at_put_("initialize","initialization");
+$ctx1.sendIdx["at:put:"]=4;
+_st($1)._at_put_("accept","visitor");
+$ctx1.sendIdx["at:put:"]=5;
+_st($1)._at_put_("visit","visitor");
+$ctx1.sendIdx["at:put:"]=6;
+_st($1)._at_put_("signal","signalling");
+$ctx1.sendIdx["at:put:"]=7;
+_st($1)._at_put_("parse","parsing");
+$ctx1.sendIdx["at:put:"]=8;
+_st($1)._at_put_("add","adding");
+$ctx1.sendIdx["at:put:"]=9;
+_st($1)._at_put_("is","testing");
+$ctx1.sendIdx["at:put:"]=10;
+_st($1)._at_put_("as","converting");
+$ctx1.sendIdx["at:put:"]=11;
+$2=_st($1)._at_put_("new","instance creation");
+return self}, function($ctx1) {$ctx1.fill(self,"buildPrefixDictionary",{},globals.HLPrefixClassifier)})},
+args: [],
+source: "buildPrefixDictionary\x0a\x09prefixMapping := Dictionary new.\x0a\x09prefixMapping \x0a\x09\x09at: 'test' put: 'tests';\x0a\x09 \x09at: 'bench' put: 'benchmarking';\x0a\x09 \x09at: 'copy' put: 'copying';\x0a\x09\x09at: 'initialize' put: 'initialization';\x0a\x09\x09at: 'accept' put: 'visitor';\x0a\x09\x09at: 'visit' put: 'visitor';\x0a\x09\x09at: 'signal' put: 'signalling';\x0a\x09\x09at: 'parse' put: 'parsing';\x0a\x09\x09at: 'add' put: 'adding';\x0a\x09\x09at: 'is' put: 'testing';\x0a\x09\x09at: 'as' put: 'converting';\x0a\x09\x09at: 'new' put: 'instance creation'.",
+messageSends: ["new", "at:put:"],
+referencedClasses: ["Dictionary"]
+}),
+globals.HLPrefixClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doClassify",
+protocol: 'private',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+var $early={};
+try {
+_st(self["@prefixMapping"])._keysAndValuesDo_((function(prefix,protocol){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(_st(self["@method"])._selector())._beginsWith_(prefix);
+if(smalltalk.assert($1)){
+_st(self["@method"])._protocol_(protocol);
+throw $early=[true];
+};
+}, function($ctx2) {$ctx2.fillBlock({prefix:prefix,protocol:protocol},$ctx1,1)})}));
+return false;
+}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{},globals.HLPrefixClassifier)})},
+args: [],
+source: "doClassify\x0a\x09prefixMapping keysAndValuesDo: [ :prefix :protocol |\x0a\x09\x09(method selector beginsWith: prefix)\x0a\x09\x09\x09ifTrue: [\x0a\x09\x09\x09\x09method protocol: protocol.\x0a\x09\x09\x09\x09^ true ]].\x0a\x09^ false.",
+messageSends: ["keysAndValuesDo:", "ifTrue:", "beginsWith:", "selector", "protocol:"],
+referencedClasses: []
+}),
+globals.HLPrefixClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLPrefixClassifier.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._buildPrefixDictionary();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLPrefixClassifier)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x0a\x09self buildPrefixDictionary",
+messageSends: ["initialize", "buildPrefixDictionary"],
+referencedClasses: []
+}),
+globals.HLPrefixClassifier);
+
+
+
+smalltalk.addClass('HLSuperclassClassifier', globals.HLClassifier, [], 'Helios-Helpers');
+globals.HLSuperclassClassifier.comment="I am a classifier checking the superclass chain to find a matching selector.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doClassify",
+protocol: 'private',
+fn: function (){
+var self=this;
+var protocolBag,methods,protocolToUse,counter;
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+function $HLReferencesModel(){return globals.HLReferencesModel||(typeof HLReferencesModel=="undefined"?nil:HLReferencesModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$4,$3,$5;
+var $early={};
+try {
+protocolBag=_st($Dictionary())._new();
+$ctx1.sendIdx["new"]=1;
+methods=_st(_st($HLReferencesModel())._new())._implementorsOf_(_st(self["@method"])._selector());
+_st(methods)._ifEmpty_ifNotEmpty_((function(){
+throw $early=[false];
+}),(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(methods)._do_((function(aMethod){
+var protocol;
+return smalltalk.withContext(function($ctx3) {
+protocol=_st(_st(aMethod)._method())._protocol();
+protocol;
+$2=_st(self["@method"])._methodClass();
+$ctx3.sendIdx["methodClass"]=1;
+$1=_st($2).__eq(_st(aMethod)._methodClass());
+$ctx3.sendIdx["="]=1;
+if(! smalltalk.assert($1)){
+$4=_st(_st(protocol)._first()).__eq("*");
+$ctx3.sendIdx["="]=2;
+$3=_st($4)._or_((function(){
+return smalltalk.withContext(function($ctx4) {
+return _st(protocol).__eq(_st(self["@method"])._defaultProtocol());
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,5)})}));
+if(! smalltalk.assert($3)){
+return _st(protocolBag)._at_put_(protocol,_st(_st(protocolBag)._at_ifAbsent_(protocol,(function(){
+return (0);
+}))).__plus((1)));
+};
+};
+}, function($ctx3) {$ctx3.fillBlock({aMethod:aMethod,protocol:protocol},$ctx2,3)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+_st(protocolBag)._ifEmpty_((function(){
+throw $early=[false];
+}));
+protocolToUse=nil;
+counter=(0);
+_st(protocolBag)._keysAndValuesDo_((function(key,value){
+return smalltalk.withContext(function($ctx2) {
+$5=_st(value).__gt(counter);
+if(smalltalk.assert($5)){
+counter=value;
+counter;
+protocolToUse=key;
+return protocolToUse;
+};
+}, function($ctx2) {$ctx2.fillBlock({key:key,value:value},$ctx1,9)})}));
+_st(self["@method"])._protocol_(protocolToUse);
+return true;
+}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{protocolBag:protocolBag,methods:methods,protocolToUse:protocolToUse,counter:counter},globals.HLSuperclassClassifier)})},
+args: [],
+source: "doClassify\x0a\x09| protocolBag methods protocolToUse counter |\x0a\x09\x0a\x09protocolBag := Dictionary new.\x0a\x09methods := HLReferencesModel new implementorsOf: method selector.\x0a\x09methods\x0a\x09\x09ifEmpty: [ ^ false ]\x0a\x09\x09ifNotEmpty: [\x0a\x09\x09\x09methods \x0a\x09\x09\x09\x09do: [ :aMethod || protocol |\x0a\x09\x09\x09\x09\x09protocol := aMethod method protocol.\x0a\x09\x09\x09\x09\x09(method methodClass = aMethod methodClass)\x0a\x09\x09\x09\x09\x09\x09ifFalse: [\x0a\x09\x09\x09\x09\x09\x09((protocol first = '*') or: [ protocol = method defaultProtocol ])\x0a\x09\x09\x09\x09\x09\x09\x09ifFalse: [ \x0a\x09\x09\x09\x09\x09\x09\x09\x09protocolBag \x0a\x09\x09\x09\x09\x09\x09\x09\x09\x09at: protocol \x0a\x09\x09\x09\x09\x09\x09\x09\x09\x09put: (protocolBag at: protocol ifAbsent: [ 0 ]) + 1 ] ] ] ].\x0a\x09\x09\x09\x0a\x09protocolBag ifEmpty: [ ^ false ].\x0a\x09protocolToUse := nil.\x0a\x09counter := 0.\x0a\x09protocolBag keysAndValuesDo: [ :key :value | value > counter \x0a\x09\x09ifTrue: [\x0a\x09\x09\x09counter := value.\x0a\x09\x09\x09protocolToUse := key ] ].\x0a\x09method protocol: protocolToUse.\x0a\x09^ true",
+messageSends: ["new", "implementorsOf:", "selector", "ifEmpty:ifNotEmpty:", "do:", "protocol", "method", "ifFalse:", "=", "methodClass", "or:", "first", "defaultProtocol", "at:put:", "+", "at:ifAbsent:", "ifEmpty:", "keysAndValuesDo:", "ifTrue:", ">", "protocol:"],
+referencedClasses: ["Dictionary", "HLReferencesModel"]
+}),
+globals.HLSuperclassClassifier);
+
+
+
+smalltalk.addClass('HLGenerationOutput', globals.Object, ['sourceCodes', 'protocol', 'targetClass'], 'Helios-Helpers');
+globals.HLGenerationOutput.comment="I am a simple data object used to store the result of a generation process.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addSourceCode:",
+protocol: 'protocol',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@sourceCodes"])._add_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"addSourceCode:",{aString:aString},globals.HLGenerationOutput)})},
+args: ["aString"],
+source: "addSourceCode: aString\x0a\x09sourceCodes add: aString",
+messageSends: ["add:"],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "compile",
+protocol: 'protocol',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(self["@sourceCodes"])._do_((function(methodSourceCode){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(self["@targetClass"])._includesSelector_(_st(methodSourceCode)._selector());
+if(! smalltalk.assert($1)){
+return _st(self["@targetClass"])._compile_protocol_(_st(methodSourceCode)._sourceCode(),self["@protocol"]);
+};
+}, function($ctx2) {$ctx2.fillBlock({methodSourceCode:methodSourceCode},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"compile",{},globals.HLGenerationOutput)})},
+args: [],
+source: "compile\x0a\x09sourceCodes do: [ :methodSourceCode |\x0a\x09\x09(targetClass includesSelector: methodSourceCode selector)\x0a\x09\x09\x09ifFalse: [ \x0a\x09\x09\x09\x09targetClass \x0a\x09\x09\x09\x09\x09compile: methodSourceCode sourceCode\x0a\x09\x09\x09\x09\x09protocol: protocol ] ]",
+messageSends: ["do:", "ifFalse:", "includesSelector:", "selector", "compile:protocol:", "sourceCode"],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLGenerationOutput.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self["@sourceCodes"]=_st($OrderedCollection())._new();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLGenerationOutput)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09\x0a\x09sourceCodes := OrderedCollection new",
+messageSends: ["initialize", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "protocol",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@protocol"];
+return $1;
+},
+args: [],
+source: "protocol\x0a\x09^ protocol",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "protocol:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@protocol"]=aString;
+return self},
+args: ["aString"],
+source: "protocol: aString\x0a\x09protocol := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sourceCodes",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@sourceCodes"];
+return $1;
+},
+args: [],
+source: "sourceCodes\x0a\x09^ sourceCodes",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sourceCodes:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@sourceCodes"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "sourceCodes: aCollection\x0a\x09sourceCodes := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "targetClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@targetClass"];
+return $1;
+},
+args: [],
+source: "targetClass\x0a\x09^ targetClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "targetClass:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+self["@targetClass"]=aClass;
+return self},
+args: ["aClass"],
+source: "targetClass: aClass\x0a\x09targetClass := aClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLGenerationOutput);
+
+
+
+smalltalk.addClass('HLMethodClassifier', globals.Object, ['firstClassifier'], 'Helios-Helpers');
+globals.HLMethodClassifier.comment="I am in charge of categorizing methods following this strategy:\x0a\x0a- is it an accessor?\x0a- is it overriding a superclass method?\x0a- is it starting with a know prefix?\x0a- how are categorized the other implementations?";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addClassifier:",
+protocol: 'private',
+fn: function (aClassifier){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(aClassifier)._next_(self["@firstClassifier"]);
+self["@firstClassifier"]=aClassifier;
+return self}, function($ctx1) {$ctx1.fill(self,"addClassifier:",{aClassifier:aClassifier},globals.HLMethodClassifier)})},
+args: ["aClassifier"],
+source: "addClassifier: aClassifier\x0a\x09aClassifier next: firstClassifier.\x0a\x09firstClassifier := aClassifier",
+messageSends: ["next:"],
+referencedClasses: []
+}),
+globals.HLMethodClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classify:",
+protocol: 'protocol',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self["@firstClassifier"];
+_st($1)._method_(aMethod);
+$2=_st($1)._classify();
+return self}, function($ctx1) {$ctx1.fill(self,"classify:",{aMethod:aMethod},globals.HLMethodClassifier)})},
+args: ["aMethod"],
+source: "classify: aMethod\x0a\x09firstClassifier\x0a\x09\x09method: aMethod;\x0a\x09\x09classify",
+messageSends: ["method:", "classify"],
+referencedClasses: []
+}),
+globals.HLMethodClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classifyAll:",
+protocol: 'protocol',
+fn: function (aCollectionOfMethods){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(aCollectionOfMethods)._do_((function(method){
+return smalltalk.withContext(function($ctx2) {
+return self._classify_(method);
+}, function($ctx2) {$ctx2.fillBlock({method:method},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"classifyAll:",{aCollectionOfMethods:aCollectionOfMethods},globals.HLMethodClassifier)})},
+args: ["aCollectionOfMethods"],
+source: "classifyAll: aCollectionOfMethods\x0a\x09aCollectionOfMethods do: [ :method |\x0a\x09\x09self classify: method ]",
+messageSends: ["do:", "classify:"],
+referencedClasses: []
+}),
+globals.HLMethodClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLMethodClassifier.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._setupClassifiers();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLMethodClassifier)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09\x0a\x09self setupClassifiers",
+messageSends: ["initialize", "setupClassifiers"],
+referencedClasses: []
+}),
+globals.HLMethodClassifier);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupClassifiers",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+function $HLImplementorClassifier(){return globals.HLImplementorClassifier||(typeof HLImplementorClassifier=="undefined"?nil:HLImplementorClassifier)}
+function $HLPrefixClassifier(){return globals.HLPrefixClassifier||(typeof HLPrefixClassifier=="undefined"?nil:HLPrefixClassifier)}
+function $HLSuperclassClassifier(){return globals.HLSuperclassClassifier||(typeof HLSuperclassClassifier=="undefined"?nil:HLSuperclassClassifier)}
+function $HLAccessorClassifier(){return globals.HLAccessorClassifier||(typeof HLAccessorClassifier=="undefined"?nil:HLAccessorClassifier)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+$1=_st($HLImplementorClassifier())._new();
+$ctx1.sendIdx["new"]=1;
+self._addClassifier_($1);
+$ctx1.sendIdx["addClassifier:"]=1;
+$2=_st($HLPrefixClassifier())._new();
+$ctx1.sendIdx["new"]=2;
+self._addClassifier_($2);
+$ctx1.sendIdx["addClassifier:"]=2;
+$3=_st($HLSuperclassClassifier())._new();
+$ctx1.sendIdx["new"]=3;
+self._addClassifier_($3);
+$ctx1.sendIdx["addClassifier:"]=3;
+self._addClassifier_(_st($HLAccessorClassifier())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"setupClassifiers",{},globals.HLMethodClassifier)})},
+args: [],
+source: "setupClassifiers\x0a\x09self addClassifier: HLImplementorClassifier new.\x0a\x09self addClassifier: HLPrefixClassifier new.\x0a\x09self addClassifier: HLSuperclassClassifier new.\x0a\x09self addClassifier: HLAccessorClassifier new",
+messageSends: ["addClassifier:", "new"],
+referencedClasses: ["HLImplementorClassifier", "HLPrefixClassifier", "HLSuperclassClassifier", "HLAccessorClassifier"]
+}),
+globals.HLMethodClassifier);
+
+
+
+smalltalk.addClass('HLMethodGenerator', globals.Object, ['output'], 'Helios-Helpers');
+globals.HLMethodGenerator.comment="I am the abstract super class of the method generators.\x0a\x0aMy main method is `generate` which produces an `output` object accessed with `#output`.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "class:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@output"])._targetClass_(aClass);
+return self}, function($ctx1) {$ctx1.fill(self,"class:",{aClass:aClass},globals.HLMethodGenerator)})},
+args: ["aClass"],
+source: "class: aClass\x0a\x09output targetClass: aClass",
+messageSends: ["targetClass:"],
+referencedClasses: []
+}),
+globals.HLMethodGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "generate",
+protocol: 'protocol',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=_st(self["@output"])._targetClass();
+if(($receiver = $1) == null || $receiver.isNil){
+self._error_("class should not be nil");
+} else {
+$1;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"generate",{},globals.HLMethodGenerator)})},
+args: [],
+source: "generate\x0a\x09output targetClass ifNil: [ self error: 'class should not be nil'].",
+messageSends: ["ifNil:", "targetClass", "error:"],
+referencedClasses: []
+}),
+globals.HLMethodGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+function $HLGenerationOutput(){return globals.HLGenerationOutput||(typeof HLGenerationOutput=="undefined"?nil:HLGenerationOutput)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLMethodGenerator.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self["@output"]=_st($HLGenerationOutput())._new();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLMethodGenerator)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09\x0a\x09output := HLGenerationOutput new",
+messageSends: ["initialize", "new"],
+referencedClasses: ["HLGenerationOutput"]
+}),
+globals.HLMethodGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "output",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@output"];
+return $1;
+},
+args: [],
+source: "output\x0a\x09^ output",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodGenerator);
+
+
+
+smalltalk.addClass('HLAccessorsGenerator', globals.HLMethodGenerator, [], 'Helios-Helpers');
+globals.HLAccessorsGenerator.comment="I am a generator used to compile the getters/setters of a class.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "accessorProtocolForObject",
+protocol: 'double-dispatch',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@output"])._protocol_("accessing");
+return self}, function($ctx1) {$ctx1.fill(self,"accessorProtocolForObject",{},globals.HLAccessorsGenerator)})},
+args: [],
+source: "accessorProtocolForObject\x0a\x09output protocol: 'accessing'",
+messageSends: ["protocol:"],
+referencedClasses: []
+}),
+globals.HLAccessorsGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "accessorsForObject",
+protocol: 'double-dispatch',
+fn: function (){
+var self=this;
+var sources;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+sources=_st($OrderedCollection())._new();
+_st(_st(_st(_st(self["@output"])._targetClass())._instanceVariableNames())._sorted())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$1=sources;
+_st($1)._add_(self._getterFor_(each));
+$ctx2.sendIdx["add:"]=1;
+$2=_st($1)._add_(self._setterFor_(each));
+return $2;
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+_st(self["@output"])._sourceCodes_(sources);
+return self}, function($ctx1) {$ctx1.fill(self,"accessorsForObject",{sources:sources},globals.HLAccessorsGenerator)})},
+args: [],
+source: "accessorsForObject\x0a\x09| sources |\x0a\x09\x0a\x09sources := OrderedCollection new.\x0a\x09output targetClass instanceVariableNames sorted do: [ :each | \x0a\x09\x09sources \x0a\x09\x09\x09add: (self getterFor: each);\x0a\x09\x09\x09add: (self setterFor: each) ].\x0a\x09output sourceCodes: sources",
+messageSends: ["new", "do:", "sorted", "instanceVariableNames", "targetClass", "add:", "getterFor:", "setterFor:", "sourceCodes:"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLAccessorsGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "generate",
+protocol: 'protocol',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+($ctx1.supercall = true, globals.HLAccessorsGenerator.superclass.fn.prototype._generate.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st(self["@output"])._targetClass();
+_st($1)._accessorsSourceCodesWith_(self);
+$2=_st($1)._accessorProtocolWith_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"generate",{},globals.HLAccessorsGenerator)})},
+args: [],
+source: "generate\x0a\x09super generate.\x0a\x09\x0a\x09output targetClass \x0a\x09\x09accessorsSourceCodesWith: self;\x0a\x09\x09accessorProtocolWith: self",
+messageSends: ["generate", "accessorsSourceCodesWith:", "targetClass", "accessorProtocolWith:"],
+referencedClasses: []
+}),
+globals.HLAccessorsGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "getterFor:",
+protocol: 'private',
+fn: function (anInstanceVariable){
+var self=this;
+function $HLMethodSourceCode(){return globals.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=_st($HLMethodSourceCode())._new();
+_st($2)._selector_(anInstanceVariable);
+$3=_st($2)._sourceCode_(_st($String())._streamContents_((function(stream){
+return smalltalk.withContext(function($ctx2) {
+_st(stream).__lt_lt(anInstanceVariable);
+$ctx2.sendIdx["<<"]=1;
+_st(_st(stream)._cr())._tab();
+return _st(_st(stream).__lt_lt("^ ")).__lt_lt(anInstanceVariable);
+$ctx2.sendIdx["<<"]=2;
+}, function($ctx2) {$ctx2.fillBlock({stream:stream},$ctx1,1)})})));
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"getterFor:",{anInstanceVariable:anInstanceVariable},globals.HLAccessorsGenerator)})},
+args: ["anInstanceVariable"],
+source: "getterFor: anInstanceVariable\x0a\x09^ HLMethodSourceCode new\x0a\x09\x09selector:anInstanceVariable;\x0a\x09\x09sourceCode: (String streamContents: [ :stream |\x0a\x09\x09stream << anInstanceVariable.\x0a\x09\x09stream cr tab.\x0a\x09\x09stream << '^ ' << anInstanceVariable ])",
+messageSends: ["selector:", "new", "sourceCode:", "streamContents:", "<<", "tab", "cr"],
+referencedClasses: ["HLMethodSourceCode", "String"]
+}),
+globals.HLAccessorsGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setterFor:",
+protocol: 'private',
+fn: function (anInstanceVariable){
+var self=this;
+function $HLMethodSourceCode(){return globals.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$4,$3,$1;
+$2=_st($HLMethodSourceCode())._new();
+_st($2)._selector_(_st(anInstanceVariable).__comma(":"));
+$3=_st($2)._sourceCode_(_st($String())._streamContents_((function(stream){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(stream).__lt_lt(anInstanceVariable);
+$ctx2.sendIdx["<<"]=2;
+_st($4).__lt_lt(": anObject");
+$ctx2.sendIdx["<<"]=1;
+_st(_st(stream)._cr())._tab();
+return _st(_st(stream).__lt_lt(anInstanceVariable)).__lt_lt(" := anObject");
+$ctx2.sendIdx["<<"]=3;
+}, function($ctx2) {$ctx2.fillBlock({stream:stream},$ctx1,1)})})));
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"setterFor:",{anInstanceVariable:anInstanceVariable},globals.HLAccessorsGenerator)})},
+args: ["anInstanceVariable"],
+source: "setterFor: anInstanceVariable\x0a\x09^ HLMethodSourceCode new\x0a\x09\x09selector: anInstanceVariable, ':';\x0a\x09\x09sourceCode: (String streamContents: [ :stream |\x0a\x09\x09stream << anInstanceVariable << ': anObject'.\x0a\x09\x09stream cr tab.\x0a\x09\x09stream << anInstanceVariable << ' := anObject' ])",
+messageSends: ["selector:", "new", ",", "sourceCode:", "streamContents:", "<<", "tab", "cr"],
+referencedClasses: ["HLMethodSourceCode", "String"]
+}),
+globals.HLAccessorsGenerator);
+
+
+
+smalltalk.addClass('HLInitializeGenerator', globals.HLMethodGenerator, [], 'Helios-Helpers');
+globals.HLInitializeGenerator.comment="I am used to double-dispatch the `initialize` method(s) generation. I am a disposable object.\x0a\x0a## Usage\x0a\x0a    ^ HLInitializeGenerator new\x0a        class: aClass;\x0a        generate;\x0a        output";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "generate",
+protocol: 'protocol',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+($ctx1.supercall = true, globals.HLInitializeGenerator.superclass.fn.prototype._generate.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st(self["@output"])._targetClass();
+_st($1)._initializeSourceCodesWith_(self);
+$2=_st($1)._initializeProtocolWith_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"generate",{},globals.HLInitializeGenerator)})},
+args: [],
+source: "generate\x0a\x09super generate.\x0a\x09\x0a\x09output targetClass \x0a\x09\x09initializeSourceCodesWith: self;\x0a\x09\x09initializeProtocolWith: self",
+messageSends: ["generate", "initializeSourceCodesWith:", "targetClass", "initializeProtocolWith:"],
+referencedClasses: []
+}),
+globals.HLInitializeGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "generateInitializeCodeForObject",
+protocol: 'private',
+fn: function (){
+var self=this;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$4,$5,$6,$7,$8,$1;
+$1=_st($String())._streamContents_((function(str){
+var instVars,size;
+return smalltalk.withContext(function($ctx2) {
+instVars=_st(_st(_st(self["@output"])._targetClass())._instanceVariableNames())._sorted();
+instVars;
+size=_st(instVars)._size();
+size;
+_st(str).__lt_lt("initialize");
+$ctx2.sendIdx["<<"]=1;
+$3=_st(str)._cr();
+$ctx2.sendIdx["cr"]=1;
+$2=_st($3)._tab();
+$ctx2.sendIdx["tab"]=1;
+_st($2).__lt_lt("super initialize.");
+$ctx2.sendIdx["<<"]=2;
+$4=_st($2)._cr();
+$ctx2.sendIdx["cr"]=2;
+$4;
+$5=_st(str)._cr();
+$ctx2.sendIdx["cr"]=3;
+_st($5)._tab();
+$ctx2.sendIdx["tab"]=2;
+return _st(instVars)._withIndexDo_((function(name,index){
+return smalltalk.withContext(function($ctx3) {
+$6=_st(index).__tild_eq((1));
+$ctx3.sendIdx["~="]=1;
+if(smalltalk.assert($6)){
+_st(_st(str)._cr())._tab();
+};
+$7=_st(str).__lt_lt(name);
+$ctx3.sendIdx["<<"]=4;
+_st($7).__lt_lt(" := nil");
+$ctx3.sendIdx["<<"]=3;
+$8=_st(index).__tild_eq(size);
+if(smalltalk.assert($8)){
+return _st(str).__lt_lt(".");
+};
+}, function($ctx3) {$ctx3.fillBlock({name:name,index:index},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({str:str,instVars:instVars,size:size},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"generateInitializeCodeForObject",{},globals.HLInitializeGenerator)})},
+args: [],
+source: "generateInitializeCodeForObject\x09\x0a\x09^ String streamContents: [ :str || instVars size |\x0a\x09\x09instVars := output targetClass instanceVariableNames sorted.\x0a\x09\x09size := instVars size.\x0a\x09\x09str << 'initialize'.\x0a\x09\x09str cr tab << 'super initialize.';cr.\x0a\x09\x09str cr tab.\x0a\x09\x09instVars withIndexDo: [ :name :index |\x0a\x09\x09\x09index ~= 1 ifTrue: [ str cr tab ].\x0a\x09\x09\x09str << name << ' := nil'.\x0a\x09\x09\x09index ~= size ifTrue: [ str << '.' ] ] ].",
+messageSends: ["streamContents:", "sorted", "instanceVariableNames", "targetClass", "size", "<<", "tab", "cr", "withIndexDo:", "ifTrue:", "~="],
+referencedClasses: ["String"]
+}),
+globals.HLInitializeGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeForObject",
+protocol: 'double-dispatch',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@output"])._addSourceCode_(self._initializeMethodForObject());
+return self}, function($ctx1) {$ctx1.fill(self,"initializeForObject",{},globals.HLInitializeGenerator)})},
+args: [],
+source: "initializeForObject\x0a\x09output addSourceCode: self initializeMethodForObject",
+messageSends: ["addSourceCode:", "initializeMethodForObject"],
+referencedClasses: []
+}),
+globals.HLInitializeGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeMethodForObject",
+protocol: 'private',
+fn: function (){
+var self=this;
+function $HLMethodSourceCode(){return globals.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=_st($HLMethodSourceCode())._new();
+_st($2)._selector_("initialize");
+_st($2)._sourceCode_(self._generateInitializeCodeForObject());
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"initializeMethodForObject",{},globals.HLInitializeGenerator)})},
+args: [],
+source: "initializeMethodForObject\x09\x0a\x09^ HLMethodSourceCode new\x0a\x09\x09selector: 'initialize';\x0a\x09\x09sourceCode: self generateInitializeCodeForObject;\x0a\x09\x09yourself",
+messageSends: ["selector:", "new", "sourceCode:", "generateInitializeCodeForObject", "yourself"],
+referencedClasses: ["HLMethodSourceCode"]
+}),
+globals.HLInitializeGenerator);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeProtocolForObject",
+protocol: 'double-dispatch',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@output"])._protocol_("initialization");
+return self}, function($ctx1) {$ctx1.fill(self,"initializeProtocolForObject",{},globals.HLInitializeGenerator)})},
+args: [],
+source: "initializeProtocolForObject\x0a\x09output protocol: 'initialization'",
+messageSends: ["protocol:"],
+referencedClasses: []
+}),
+globals.HLInitializeGenerator);
+
+
+
+smalltalk.addClass('HLMethodSourceCode', globals.Object, ['selector', 'sourceCode'], 'Helios-Helpers');
+globals.HLMethodSourceCode.comment="I am a simple data object keeping track of the information about a method that will be compiled at the end of the generation process.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selector",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selector"];
+return $1;
+},
+args: [],
+source: "selector\x0a\x09^ selector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodSourceCode);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selector:",
+protocol: 'accessing',
+fn: function (aSelector){
+var self=this;
+self["@selector"]=aSelector;
+return self},
+args: ["aSelector"],
+source: "selector: aSelector\x0a\x09selector := aSelector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodSourceCode);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sourceCode",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@sourceCode"];
+return $1;
+},
+args: [],
+source: "sourceCode\x0a\x09^ sourceCode",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodSourceCode);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sourceCode:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@sourceCode"]=aString;
+return self},
+args: ["aString"],
+source: "sourceCode: aString\x0a\x09sourceCode := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodSourceCode);
+
+
+
+smalltalk.addClass('HLPackageCommitErrorHelper', globals.Object, ['model'], 'Helios-Helpers');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commitPackage",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLCommitPackageCommand(){return globals.HLCommitPackageCommand||(typeof HLCommitPackageCommand=="undefined"?nil:HLCommitPackageCommand)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLCommitPackageCommand())._for_(self._model()))._execute();
+return self}, function($ctx1) {$ctx1.fill(self,"commitPackage",{},globals.HLPackageCommitErrorHelper)})},
+args: [],
+source: "commitPackage\x0a\x09(HLCommitPackageCommand for: self model)\x0a\x09\x09execute",
+messageSends: ["execute", "for:", "model"],
+referencedClasses: ["HLCommitPackageCommand"]
+}),
+globals.HLPackageCommitErrorHelper);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commitToPath:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._package())._transport())._setPath_(aString);
+self._commitPackage();
+return self}, function($ctx1) {$ctx1.fill(self,"commitToPath:",{aString:aString},globals.HLPackageCommitErrorHelper)})},
+args: ["aString"],
+source: "commitToPath: aString\x0a\x09\x22We only take AMD package transport into account for now\x22\x0a\x09\x0a\x09self package transport setPath: aString.\x0a\x09\x0a\x09self commitPackage",
+messageSends: ["setPath:", "transport", "package", "commitPackage"],
+referencedClasses: []
+}),
+globals.HLPackageCommitErrorHelper);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@model"];
+return $1;
+},
+args: [],
+source: "model\x0a\x09^ model",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLPackageCommitErrorHelper);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aToolModel){
+var self=this;
+self["@model"]=aToolModel;
+return self},
+args: ["aToolModel"],
+source: "model: aToolModel\x0a\x09model := aToolModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLPackageCommitErrorHelper);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "package",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._packageToCommit();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"package",{},globals.HLPackageCommitErrorHelper)})},
+args: [],
+source: "package\x0a\x09^ self model packageToCommit",
+messageSends: ["packageToCommit", "model"],
+referencedClasses: []
+}),
+globals.HLPackageCommitErrorHelper);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showHelp",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLConfirmationWidget(){return globals.HLConfirmationWidget||(typeof HLConfirmationWidget=="undefined"?nil:HLConfirmationWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4;
+$1=_st($HLConfirmationWidget())._new();
+$2=$1;
+$3=_st("Commit failed for namespace \x22".__comma(_st(_st(self._package())._transport())._namespace())).__comma("\x22. Do you want to commit to another path?");
+$ctx1.sendIdx[","]=1;
+_st($2)._confirmationString_($3);
+_st($1)._actionBlock_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._showNewCommitPath();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+_st($1)._cancelButtonLabel_("Abandon");
+_st($1)._confirmButtonLabel_("Set path");
+$4=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"showHelp",{},globals.HLPackageCommitErrorHelper)})},
+args: [],
+source: "showHelp\x0a\x09HLConfirmationWidget new\x0a\x09\x09confirmationString: 'Commit failed for namespace \x22', self package transport namespace, '\x22. Do you want to commit to another path?';\x0a\x09\x09actionBlock: [ self showNewCommitPath ];\x0a\x09\x09cancelButtonLabel: 'Abandon';\x0a\x09\x09confirmButtonLabel: 'Set path';\x0a\x09\x09show\x0a\x09",
+messageSends: ["confirmationString:", "new", ",", "namespace", "transport", "package", "actionBlock:", "showNewCommitPath", "cancelButtonLabel:", "confirmButtonLabel:", "show"],
+referencedClasses: ["HLConfirmationWidget"]
+}),
+globals.HLPackageCommitErrorHelper);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showNewCommitPath",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLRequestWidget(){return globals.HLRequestWidget||(typeof HLRequestWidget=="undefined"?nil:HLRequestWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLRequestWidget())._new();
+_st($1)._beSingleline();
+_st($1)._confirmationString_("Set commit path");
+_st($1)._actionBlock_((function(url){
+return smalltalk.withContext(function($ctx2) {
+return self._commitToPath_(url);
+}, function($ctx2) {$ctx2.fillBlock({url:url},$ctx1,1)})}));
+_st($1)._confirmButtonLabel_("Commit with new path");
+_st($1)._value_("/src");
+$2=_st($1)._show();
+return self}, function($ctx1) {$ctx1.fill(self,"showNewCommitPath",{},globals.HLPackageCommitErrorHelper)})},
+args: [],
+source: "showNewCommitPath\x0a\x09HLRequestWidget new\x0a\x09\x09beSingleline;\x0a\x09\x09confirmationString: 'Set commit path';\x0a\x09\x09actionBlock: [ :url | self commitToPath: url ];\x0a\x09\x09confirmButtonLabel: 'Commit with new path';\x0a\x09\x09value: '/src';\x0a\x09\x09show",
+messageSends: ["beSingleline", "new", "confirmationString:", "actionBlock:", "commitToPath:", "confirmButtonLabel:", "value:", "show"],
+referencedClasses: ["HLRequestWidget"]
+}),
+globals.HLPackageCommitErrorHelper);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aToolModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._model_(aToolModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aToolModel:aToolModel},globals.HLPackageCommitErrorHelper.klass)})},
+args: ["aToolModel"],
+source: "on: aToolModel\x0a\x09^ self new\x0a\x09\x09model: aToolModel;\x0a\x09\x09yourself",
+messageSends: ["model:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLPackageCommitErrorHelper.klass);
+
+});

src/Helios-Helpers.st

@@ -0,0 +1,497 @@
+Smalltalk createPackage: 'Helios-Helpers'!
+Object subclass: #HLClassifier
+	instanceVariableNames: 'next method'
+	package: 'Helios-Helpers'!
+!HLClassifier commentStamp!
+I am an abstract class implementing a link in a `chain of responsibility` pattern.
+
+Subclasses are in charge of classifying a method according to multiple strategies.!
+
+!HLClassifier methodsFor: 'accessing'!
+
+method
+	^ method
+!
+
+method: anObject
+	method := anObject.
+	self next
+		ifNotNil: [ :nextLink | nextLink method: anObject ]
+!
+
+next
+	^ next
+!
+
+next: anObject
+	next := anObject
+! !
+
+!HLClassifier methodsFor: 'private'!
+
+doClassify
+	self subclassResponsibility
+! !
+
+!HLClassifier methodsFor: 'protocol'!
+
+classify
+	self next ifNil: [ ^ false ].
+	
+	^ self doClassify
+		ifTrue: [ true ]
+		ifFalse: [ self next classify ]
+! !
+
+HLClassifier subclass: #HLAccessorClassifier
+	instanceVariableNames: ''
+	package: 'Helios-Helpers'!
+!HLAccessorClassifier commentStamp!
+I am a classifier checking the method selector matches an instance variable name.!
+
+!HLAccessorClassifier methodsFor: 'private'!
+
+doClassify
+	| names selector |
+	
+	names := method methodClass allInstanceVariableNames.
+	selector := method selector.
+	
+	(selector last = ':')
+		ifTrue: [ "selector might be a setter"
+			selector := selector allButLast ].
+	
+	(names includes: selector)
+		ifFalse: [ ^ false ].
+		
+	method protocol: 'accessing'.
+	^ true.
+! !
+
+HLClassifier subclass: #HLImplementorClassifier
+	instanceVariableNames: ''
+	package: 'Helios-Helpers'!
+!HLImplementorClassifier commentStamp!
+I am a classifier checking the other implementations of the same selector and choose the protocol the most populated.!
+
+!HLImplementorClassifier methodsFor: 'private'!
+
+doClassify
+	| currentClass |
+	currentClass := method methodClass.
+	
+	[ currentClass superclass isNil ] whileFalse: [
+		currentClass := currentClass superclass.
+		(currentClass includesSelector: method selector)
+			ifTrue: [ 
+				method protocol: (currentClass >> method selector) protocol.
+				^ true ]].
+	
+	^ false.
+! !
+
+HLClassifier subclass: #HLPrefixClassifier
+	instanceVariableNames: 'prefixMapping'
+	package: 'Helios-Helpers'!
+!HLPrefixClassifier commentStamp!
+I am classifier checking the method selector to know if it begins with a known prefix.!
+
+!HLPrefixClassifier methodsFor: 'initialization'!
+
+buildPrefixDictionary
+	prefixMapping := Dictionary new.
+	prefixMapping 
+		at: 'test' put: 'tests';
+	 	at: 'bench' put: 'benchmarking';
+	 	at: 'copy' put: 'copying';
+		at: 'initialize' put: 'initialization';
+		at: 'accept' put: 'visitor';
+		at: 'visit' put: 'visitor';
+		at: 'signal' put: 'signalling';
+		at: 'parse' put: 'parsing';
+		at: 'add' put: 'adding';
+		at: 'is' put: 'testing';
+		at: 'as' put: 'converting';
+		at: 'new' put: 'instance creation'.
+!
+
+initialize
+	super initialize.
+
+	self buildPrefixDictionary
+! !
+
+!HLPrefixClassifier methodsFor: 'private'!
+
+doClassify
+	prefixMapping keysAndValuesDo: [ :prefix :protocol |
+		(method selector beginsWith: prefix)
+			ifTrue: [
+				method protocol: protocol.
+				^ true ]].
+	^ false.
+! !
+
+HLClassifier subclass: #HLSuperclassClassifier
+	instanceVariableNames: ''
+	package: 'Helios-Helpers'!
+!HLSuperclassClassifier commentStamp!
+I am a classifier checking the superclass chain to find a matching selector.!
+
+!HLSuperclassClassifier methodsFor: 'private'!
+
+doClassify
+	| protocolBag methods protocolToUse counter |
+	
+	protocolBag := Dictionary new.
+	methods := HLReferencesModel new implementorsOf: method selector.
+	methods
+		ifEmpty: [ ^ false ]
+		ifNotEmpty: [
+			methods 
+				do: [ :aMethod || protocol |
+					protocol := aMethod method protocol.
+					(method methodClass = aMethod methodClass)
+						ifFalse: [
+						((protocol first = '*') or: [ protocol = method defaultProtocol ])
+							ifFalse: [ 
+								protocolBag 
+									at: protocol 
+									put: (protocolBag at: protocol ifAbsent: [ 0 ]) + 1 ] ] ] ].
+			
+	protocolBag ifEmpty: [ ^ false ].
+	protocolToUse := nil.
+	counter := 0.
+	protocolBag keysAndValuesDo: [ :key :value | value > counter 
+		ifTrue: [
+			counter := value.
+			protocolToUse := key ] ].
+	method protocol: protocolToUse.
+	^ true
+! !
+
+Object subclass: #HLGenerationOutput
+	instanceVariableNames: 'sourceCodes protocol targetClass'
+	package: 'Helios-Helpers'!
+!HLGenerationOutput commentStamp!
+I am a simple data object used to store the result of a generation process.!
+
+!HLGenerationOutput methodsFor: 'accessing'!
+
+protocol
+	^ protocol
+!
+
+protocol: aString
+	protocol := aString
+!
+
+sourceCodes
+	^ sourceCodes
+!
+
+sourceCodes: aCollection
+	sourceCodes := aCollection
+!
+
+targetClass
+	^ targetClass
+!
+
+targetClass: aClass
+	targetClass := aClass
+! !
+
+!HLGenerationOutput methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	
+	sourceCodes := OrderedCollection new
+! !
+
+!HLGenerationOutput methodsFor: 'protocol'!
+
+addSourceCode: aString
+	sourceCodes add: aString
+!
+
+compile
+	sourceCodes do: [ :methodSourceCode |
+		(targetClass includesSelector: methodSourceCode selector)
+			ifFalse: [ 
+				targetClass 
+					compile: methodSourceCode sourceCode
+					protocol: protocol ] ]
+! !
+
+Object subclass: #HLMethodClassifier
+	instanceVariableNames: 'firstClassifier'
+	package: 'Helios-Helpers'!
+!HLMethodClassifier commentStamp!
+I am in charge of categorizing methods following this strategy:
+
+- is it an accessor?
+- is it overriding a superclass method?
+- is it starting with a know prefix?
+- how are categorized the other implementations?!
+
+!HLMethodClassifier methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	
+	self setupClassifiers
+!
+
+setupClassifiers
+	self addClassifier: HLImplementorClassifier new.
+	self addClassifier: HLPrefixClassifier new.
+	self addClassifier: HLSuperclassClassifier new.
+	self addClassifier: HLAccessorClassifier new
+! !
+
+!HLMethodClassifier methodsFor: 'private'!
+
+addClassifier: aClassifier
+	aClassifier next: firstClassifier.
+	firstClassifier := aClassifier
+! !
+
+!HLMethodClassifier methodsFor: 'protocol'!
+
+classify: aMethod
+	firstClassifier
+		method: aMethod;
+		classify
+!
+
+classifyAll: aCollectionOfMethods
+	aCollectionOfMethods do: [ :method |
+		self classify: method ]
+! !
+
+Object subclass: #HLMethodGenerator
+	instanceVariableNames: 'output'
+	package: 'Helios-Helpers'!
+!HLMethodGenerator commentStamp!
+I am the abstract super class of the method generators.
+
+My main method is `generate` which produces an `output` object accessed with `#output`.!
+
+!HLMethodGenerator methodsFor: 'accessing'!
+
+class: aClass
+	output targetClass: aClass
+!
+
+output
+	^ output
+! !
+
+!HLMethodGenerator methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	
+	output := HLGenerationOutput new
+! !
+
+!HLMethodGenerator methodsFor: 'protocol'!
+
+generate
+	output targetClass ifNil: [ self error: 'class should not be nil'].
+! !
+
+HLMethodGenerator subclass: #HLAccessorsGenerator
+	instanceVariableNames: ''
+	package: 'Helios-Helpers'!
+!HLAccessorsGenerator commentStamp!
+I am a generator used to compile the getters/setters of a class.!
+
+!HLAccessorsGenerator methodsFor: 'double-dispatch'!
+
+accessorProtocolForObject
+	output protocol: 'accessing'
+!
+
+accessorsForObject
+	| sources |
+	
+	sources := OrderedCollection new.
+	output targetClass instanceVariableNames sorted do: [ :each | 
+		sources 
+			add: (self getterFor: each);
+			add: (self setterFor: each) ].
+	output sourceCodes: sources
+! !
+
+!HLAccessorsGenerator methodsFor: 'private'!
+
+getterFor: anInstanceVariable
+	^ HLMethodSourceCode new
+		selector:anInstanceVariable;
+		sourceCode: (String streamContents: [ :stream |
+		stream << anInstanceVariable.
+		stream cr tab.
+		stream << '^ ' << anInstanceVariable ])
+!
+
+setterFor: anInstanceVariable
+	^ HLMethodSourceCode new
+		selector: anInstanceVariable, ':';
+		sourceCode: (String streamContents: [ :stream |
+		stream << anInstanceVariable << ': anObject'.
+		stream cr tab.
+		stream << anInstanceVariable << ' := anObject' ])
+! !
+
+!HLAccessorsGenerator methodsFor: 'protocol'!
+
+generate
+	super generate.
+	
+	output targetClass 
+		accessorsSourceCodesWith: self;
+		accessorProtocolWith: self
+! !
+
+HLMethodGenerator subclass: #HLInitializeGenerator
+	instanceVariableNames: ''
+	package: 'Helios-Helpers'!
+!HLInitializeGenerator commentStamp!
+I am used to double-dispatch the `initialize` method(s) generation. I am a disposable object.
+
+## Usage
+
+    ^ HLInitializeGenerator new
+        class: aClass;
+        generate;
+        output!
+
+!HLInitializeGenerator methodsFor: 'double-dispatch'!
+
+initializeForObject
+	output addSourceCode: self initializeMethodForObject
+!
+
+initializeProtocolForObject
+	output protocol: 'initialization'
+! !
+
+!HLInitializeGenerator methodsFor: 'private'!
+
+generateInitializeCodeForObject	
+	^ String streamContents: [ :str || instVars size |
+		instVars := output targetClass instanceVariableNames sorted.
+		size := instVars size.
+		str << 'initialize'.
+		str cr tab << 'super initialize.';cr.
+		str cr tab.
+		instVars withIndexDo: [ :name :index |
+			index ~= 1 ifTrue: [ str cr tab ].
+			str << name << ' := nil'.
+			index ~= size ifTrue: [ str << '.' ] ] ].
+!
+
+initializeMethodForObject	
+	^ HLMethodSourceCode new
+		selector: 'initialize';
+		sourceCode: self generateInitializeCodeForObject;
+		yourself
+! !
+
+!HLInitializeGenerator methodsFor: 'protocol'!
+
+generate
+	super generate.
+	
+	output targetClass 
+		initializeSourceCodesWith: self;
+		initializeProtocolWith: self
+! !
+
+Object subclass: #HLMethodSourceCode
+	instanceVariableNames: 'selector sourceCode'
+	package: 'Helios-Helpers'!
+!HLMethodSourceCode commentStamp!
+I am a simple data object keeping track of the information about a method that will be compiled at the end of the generation process.!
+
+!HLMethodSourceCode methodsFor: 'accessing'!
+
+selector
+	^ selector
+!
+
+selector: aSelector
+	selector := aSelector
+!
+
+sourceCode
+	^ sourceCode
+!
+
+sourceCode: aString
+	sourceCode := aString
+! !
+
+Object subclass: #HLPackageCommitErrorHelper
+	instanceVariableNames: 'model'
+	package: 'Helios-Helpers'!
+
+!HLPackageCommitErrorHelper methodsFor: 'accessing'!
+
+model
+	^ model
+!
+
+model: aToolModel
+	model := aToolModel
+!
+
+package
+	^ self model packageToCommit
+! !
+
+!HLPackageCommitErrorHelper methodsFor: 'actions'!
+
+commitPackage
+	(HLCommitPackageCommand for: self model)
+		execute
+!
+
+commitToPath: aString
+	"We only take AMD package transport into account for now"
+	
+	self package transport setPath: aString.
+	
+	self commitPackage
+!
+
+showHelp
+	HLConfirmationWidget new
+		confirmationString: 'Commit failed for namespace "', self package transport namespace, '". Do you want to commit to another path?';
+		actionBlock: [ self showNewCommitPath ];
+		cancelButtonLabel: 'Abandon';
+		confirmButtonLabel: 'Set path';
+		show
+!
+
+showNewCommitPath
+	HLRequestWidget new
+		beSingleline;
+		confirmationString: 'Set commit path';
+		actionBlock: [ :url | self commitToPath: url ];
+		confirmButtonLabel: 'Commit with new path';
+		value: '/src';
+		show
+! !
+
+!HLPackageCommitErrorHelper class methodsFor: 'instance creation'!
+
+on: aToolModel
+	^ self new
+		model: aToolModel;
+		yourself
+! !
+

src/Helios-Inspector.js

@@ -0,0 +1,1449 @@
+define("helios/Helios-Inspector", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Core"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Inspector');
+smalltalk.packages["Helios-Inspector"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLInspectorDisplayWidget', globals.HLNavigationListWidget, ['inspector'], 'Helios-Inspector');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspector",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@inspector"];
+return $1;
+},
+args: [],
+source: "inspector\x0a\x09^ inspector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorDisplayWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspector:",
+protocol: 'accessing',
+fn: function (anInspector){
+var self=this;
+self["@inspector"]=anInspector;
+return self},
+args: ["anInspector"],
+source: "inspector: anInspector\x0a\x09inspector := anInspector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorDisplayWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._inspector())._model();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLInspectorDisplayWidget)})},
+args: [],
+source: "model\x0a\x0a\x09^ self inspector model",
+messageSends: ["model", "inspector"],
+referencedClasses: []
+}),
+globals.HLInspectorDisplayWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(html)._div())._with_(self._selectionDisplayString());
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLInspectorDisplayWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09\x0a    html div with: self selectionDisplayString",
+messageSends: ["with:", "div", "selectionDisplayString"],
+referencedClasses: []
+}),
+globals.HLInspectorDisplayWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectionDisplayString",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+var selection;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$5,$4,$3,$2;
+$1=self._model();
+$ctx1.sendIdx["model"]=1;
+selection=_st($1)._selection();
+$5=self._model();
+$ctx1.sendIdx["model"]=2;
+$4=_st($5)._variables();
+$3=_st($4)._includesKey_(selection);
+if(smalltalk.assert($3)){
+$2=_st(_st(self._model())._instVarObjectAt_(selection))._printString();
+} else {
+$2="";
+};
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"selectionDisplayString",{selection:selection},globals.HLInspectorDisplayWidget)})},
+args: [],
+source: "selectionDisplayString\x0a\x09|selection|\x0a\x09selection := self model selection.\x0a    ^ (self model variables includesKey: selection)\x0a    \x09ifTrue:[ (self model instVarObjectAt: selection) printString ]\x0a      \x09ifFalse:[ '' ]",
+messageSends: ["selection", "model", "ifTrue:ifFalse:", "includesKey:", "variables", "printString", "instVarObjectAt:"],
+referencedClasses: []
+}),
+globals.HLInspectorDisplayWidget);
+
+
+
+smalltalk.addClass('HLInspectorModel', globals.HLModel, ['inspectee', 'code', 'variables', 'label', 'selection'], 'Helios-Inspector');
+globals.HLInspectorModel.comment="I am the model of the Helios inspector `HLInspectorWidget`.\x0a\x0a## API\x0a\x0aUse the method `inspect:on:` to inspect an object on an inspector.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "code",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLCodeModel(){return globals.HLCodeModel||(typeof HLCodeModel=="undefined"?nil:HLCodeModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@code"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@code"]=_st($HLCodeModel())._on_(self._environment());
+$1=self["@code"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"code",{},globals.HLInspectorModel)})},
+args: [],
+source: "code\x0a\x09\x22Answers the code model working for this workspace model\x22\x0a\x09^ code ifNil:[ code := HLCodeModel on: self environment ]",
+messageSends: ["ifNil:", "on:", "environment"],
+referencedClasses: ["HLCodeModel"]
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspect:on:",
+protocol: 'actions',
+fn: function (anObject,anInspector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@inspectee"]=anObject;
+self["@variables"]=[];
+_st(self["@inspectee"])._inspectOn_(anInspector);
+return self}, function($ctx1) {$ctx1.fill(self,"inspect:on:",{anObject:anObject,anInspector:anInspector},globals.HLInspectorModel)})},
+args: ["anObject", "anInspector"],
+source: "inspect: anObject on: anInspector\x0a\x09inspectee := anObject.\x0a\x09variables := #().\x0a\x09inspectee inspectOn: anInspector",
+messageSends: ["inspectOn:"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectee",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@inspectee"];
+return $1;
+},
+args: [],
+source: "inspectee \x0a\x09^ inspectee",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectee:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@inspectee"]=anObject;
+return self},
+args: ["anObject"],
+source: "inspectee: anObject \x0a\x09inspectee := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "instVarObjectAt:",
+protocol: 'actions',
+fn: function (anInstVarName){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._variables())._at_(anInstVarName);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"instVarObjectAt:",{anInstVarName:anInstVarName},globals.HLInspectorModel)})},
+args: ["anInstVarName"],
+source: "instVarObjectAt: anInstVarName\x0a\x09^ self variables at: anInstVarName",
+messageSends: ["at:", "variables"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@label"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=_st(self._inspectee())._printString();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"label",{},globals.HLInspectorModel)})},
+args: [],
+source: "label\x0a    ^ label ifNil: [ self inspectee printString ]",
+messageSends: ["ifNil:", "printString", "inspectee"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@label"]=aString;
+return self},
+args: ["aString"],
+source: "label: aString\x0a    label := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedInstVar:",
+protocol: 'actions',
+fn: function (anInstVarName){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selection_(anInstVarName);
+return self}, function($ctx1) {$ctx1.fill(self,"selectedInstVar:",{anInstVarName:anInstVarName},globals.HLInspectorModel)})},
+args: ["anInstVarName"],
+source: "selectedInstVar: anInstVarName\x0a    self selection: anInstVarName",
+messageSends: ["selection:"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedInstVarObject",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._instVarObjectAt_(self._selection());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedInstVarObject",{},globals.HLInspectorModel)})},
+args: [],
+source: "selectedInstVarObject\x0a\x09^ self instVarObjectAt: self selection",
+messageSends: ["instVarObjectAt:", "selection"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selection",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@selection"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selection",{},globals.HLInspectorModel)})},
+args: [],
+source: "selection\x0a\x09^ selection ifNil:[ '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selection:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+function $HLInstanceVariableSelected(){return globals.HLInstanceVariableSelected||(typeof HLInstanceVariableSelected=="undefined"?nil:HLInstanceVariableSelected)}
+return smalltalk.withContext(function($ctx1) { 
+self["@selection"]=anObject;
+_st(self._announcer())._announce_(_st($HLInstanceVariableSelected())._on_(self["@selection"]));
+return self}, function($ctx1) {$ctx1.fill(self,"selection:",{anObject:anObject},globals.HLInspectorModel)})},
+args: ["anObject"],
+source: "selection: anObject\x0a\x09selection := anObject.\x0a\x0a\x09self announcer announce: (HLInstanceVariableSelected on: selection)",
+messageSends: ["announce:", "announcer", "on:"],
+referencedClasses: ["HLInstanceVariableSelected"]
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "subscribe:",
+protocol: 'actions',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(aWidget)._subscribeTo_(self._announcer());
+return self}, function($ctx1) {$ctx1.fill(self,"subscribe:",{aWidget:aWidget},globals.HLInspectorModel)})},
+args: ["aWidget"],
+source: "subscribe: aWidget\x0a\x09aWidget subscribeTo: self announcer",
+messageSends: ["subscribeTo:", "announcer"],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variables",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@variables"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=_st($Dictionary())._new();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"variables",{},globals.HLInspectorModel)})},
+args: [],
+source: "variables\x0a\x09^ variables ifNil: [ Dictionary new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["Dictionary"]
+}),
+globals.HLInspectorModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variables:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@variables"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "variables: aCollection\x0a\x09variables := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorModel);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'actions',
+fn: function (anEnvironment){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._environment_(anEnvironment);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anEnvironment:anEnvironment},globals.HLInspectorModel.klass)})},
+args: ["anEnvironment"],
+source: "on: anEnvironment\x0a\x0a\x09^ self new\x0a    \x09environment: anEnvironment;\x0a        yourself",
+messageSends: ["environment:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLInspectorModel.klass);
+
+
+smalltalk.addClass('HLInspectorVariablesWidget', globals.HLNavigationListWidget, ['announcer', 'inspector', 'list', 'diveButton'], 'Helios-Inspector');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "announcer",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Announcer(){return globals.Announcer||(typeof Announcer=="undefined"?nil:Announcer)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@announcer"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@announcer"]=_st($Announcer())._new();
+$1=self["@announcer"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"announcer",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "announcer\x0a\x09^ announcer ifNil:[ announcer := Announcer new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["Announcer"]
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultItems",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._variables();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultItems",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "defaultItems\x0a\x09^ self variables",
+messageSends: ["variables"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "dive",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDiveRequested(){return globals.HLDiveRequested||(typeof HLDiveRequested=="undefined"?nil:HLDiveRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._announcer())._announce_(_st($HLDiveRequested())._new());
+return self}, function($ctx1) {$ctx1.fill(self,"dive",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "dive\x0a\x09self announcer announce: HLDiveRequested new",
+messageSends: ["announce:", "announcer", "new"],
+referencedClasses: ["HLDiveRequested"]
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspector",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@inspector"];
+return $1;
+},
+args: [],
+source: "inspector\x0a\x09^ inspector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspector:",
+protocol: 'accessing',
+fn: function (anInspector){
+var self=this;
+self["@inspector"]=anInspector;
+return self},
+args: ["anInspector"],
+source: "inspector: anInspector\x0a\x09inspector := anInspector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"label",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "label\x0a\x09^ self model label",
+messageSends: ["label", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._inspector())._model();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "model\x0a    ^ self inspector model",
+messageSends: ["model", "inspector"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refresh",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._variables()).__eq(self._items());
+if(! smalltalk.assert($1)){
+self._resetItems();
+($ctx1.supercall = true, globals.HLInspectorVariablesWidget.superclass.fn.prototype._refresh.apply(_st(self), []));
+$ctx1.supercall = false;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "refresh\x0a\x09self variables = self items ifFalse: [\x0a\x09\x09self resetItems.\x0a    \x09super refresh ]",
+messageSends: ["ifFalse:", "=", "variables", "items", "resetItems", "refresh"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._button();
+_st($1)._class_("btn");
+_st($1)._with_("Dive");
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._dive();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+self["@diveButton"]=$2;
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},globals.HLInspectorVariablesWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09diveButton := html button \x0a\x09\x09class: 'btn';\x0a\x09\x09with: 'Dive'; \x0a\x09\x09onClick: [ self dive ]",
+messageSends: ["class:", "button", "with:", "onClick:", "dive"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._renderHeadOn_(html);
+($ctx1.supercall = true, globals.HLInspectorVariablesWidget.superclass.fn.prototype._renderContentOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+_st(self._wrapper())._onDblClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._dive();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLInspectorVariablesWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09self renderHeadOn: html.\x0a\x09super renderContentOn: html.\x0a\x09self wrapper onDblClick: [ self dive ]",
+messageSends: ["renderHeadOn:", "renderContentOn:", "onDblClick:", "wrapper", "dive"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderHeadOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("list-label");
+$2=_st($1)._with_(self._label());
+return self}, function($ctx1) {$ctx1.fill(self,"renderHeadOn:",{html:html},globals.HLInspectorVariablesWidget)})},
+args: ["html"],
+source: "renderHeadOn: html\x0a\x09html div \x0a\x09\x09class: 'list-label';\x0a\x09\x09with: self label",
+messageSends: ["class:", "div", "with:", "label"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "resetItems",
+protocol: 'actions',
+fn: function (){
+var self=this;
+self["@items"]=nil;
+return self},
+args: [],
+source: "resetItems\x0a\x09items := nil",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'reactions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLInspectorVariablesWidget.superclass.fn.prototype._selectItem_.apply(_st(self), [anObject]));
+$ctx1.supercall = false;
+_st(self._model())._selectedInstVar_(anObject);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{anObject:anObject},globals.HLInspectorVariablesWidget)})},
+args: ["anObject"],
+source: "selectItem: anObject\x0a\x09super selectItem: anObject.\x0a    self model selectedInstVar: anObject",
+messageSends: ["selectItem:", "selectedInstVar:", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selection",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._selection();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selection",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "selection\x0a\x09^ self model selection",
+messageSends: ["selection", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variables",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._model())._variables())._keys();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"variables",{},globals.HLInspectorVariablesWidget)})},
+args: [],
+source: "variables\x0a\x09^ self model variables keys",
+messageSends: ["keys", "variables", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorVariablesWidget);
+
+
+
+smalltalk.addClass('HLInspectorWidget', globals.HLWidget, ['model', 'variablesWidget', 'displayWidget', 'codeWidget'], 'Helios-Inspector');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "codeWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@codeWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@codeWidget"]=self._defaultCodeWidget();
+$1=self["@codeWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"codeWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "codeWidget\x0a\x09^ codeWidget ifNil: [\x0a\x09\x09codeWidget := self defaultCodeWidget ]",
+messageSends: ["ifNil:", "defaultCodeWidget"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "codeWidget:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+self["@codeWidget"]=aWidget;
+return self},
+args: ["aWidget"],
+source: "codeWidget: aWidget\x0a\x09codeWidget := aWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultCodeWidget",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+function $HLCodeWidget(){return globals.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$5,$4,$6,$1;
+$2=_st($HLCodeWidget())._new();
+$3=$2;
+$5=self._model();
+$ctx1.sendIdx["model"]=1;
+$4=_st($5)._code();
+_st($3)._model_($4);
+_st($2)._receiver_(_st(self._model())._inspectee());
+$6=_st($2)._yourself();
+$1=$6;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultCodeWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "defaultCodeWidget\x0a\x09^ HLCodeWidget new\x0a    \x09model: self model code;\x0a       \x09receiver: self model inspectee;\x0a       \x09yourself",
+messageSends: ["model:", "new", "code", "model", "receiver:", "inspectee", "yourself"],
+referencedClasses: ["HLCodeWidget"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLInspectorDisplayWidget(){return globals.HLInspectorDisplayWidget||(typeof HLInspectorDisplayWidget=="undefined"?nil:HLInspectorDisplayWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@displayWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLInspectorDisplayWidget())._new();
+_st($3)._inspector_(self);
+$4=_st($3)._yourself();
+self["@displayWidget"]=$4;
+$1=self["@displayWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"displayWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "displayWidget\x0a\x09^ displayWidget ifNil: [\x0a\x09\x09displayWidget := HLInspectorDisplayWidget new\x0a    \x09\x09inspector: self;\x0a        \x09yourself ]",
+messageSends: ["ifNil:", "inspector:", "new", "yourself"],
+referencedClasses: ["HLInspectorDisplayWidget"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLInspectorWidget.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._register();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLInspectorWidget)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09self register",
+messageSends: ["initialize", "register"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspect:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(self._model())._inspect_on_(anObject,self);
+_st(self._codeWidget())._receiver_(anObject);
+self._refreshVariablesWidget();
+$1=self._refreshDisplayWidget();
+return self}, function($ctx1) {$ctx1.fill(self,"inspect:",{anObject:anObject},globals.HLInspectorWidget)})},
+args: ["anObject"],
+source: "inspect: anObject\x0a\x09self model inspect: anObject on: self.\x0a\x09self codeWidget receiver: anObject.\x0a    \x0a\x09self \x0a    \x09refreshVariablesWidget;\x0a\x09\x09refreshDisplayWidget",
+messageSends: ["inspect:on:", "model", "receiver:", "codeWidget", "refreshVariablesWidget", "refreshDisplayWidget"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectee",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._inspectee();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inspectee",{},globals.HLInspectorWidget)})},
+args: [],
+source: "inspectee\x0a\x09^ self model inspectee",
+messageSends: ["inspectee", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectee:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._inspectee_(anObject);
+return self}, function($ctx1) {$ctx1.fill(self,"inspectee:",{anObject:anObject},globals.HLInspectorWidget)})},
+args: ["anObject"],
+source: "inspectee: anObject\x0a\x09self model inspectee: anObject",
+messageSends: ["inspectee:", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"label",{},globals.HLInspectorWidget)})},
+args: [],
+source: "label\x0a    ^ self model label",
+messageSends: ["label", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLInspectorModel(){return globals.HLInspectorModel||(typeof HLInspectorModel=="undefined"?nil:HLInspectorModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@model"];
+if(($receiver = $2) == null || $receiver.isNil){
+self._model_(_st($HLInspectorModel())._new());
+$1=self["@model"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLInspectorWidget)})},
+args: [],
+source: "model\x0a\x09^ model ifNil: [ \x0a    \x09self model: HLInspectorModel new.\x0a\x09\x09model ]",
+messageSends: ["ifNil:", "model:", "new"],
+referencedClasses: ["HLInspectorModel"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self["@model"]=aModel;
+_st(self._codeWidget())._model_(_st(aModel)._code());
+self._observeCodeWidget();
+self._observeVariablesWidget();
+$1=self._observeModel();
+return self}, function($ctx1) {$ctx1.fill(self,"model:",{aModel:aModel},globals.HLInspectorWidget)})},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel. \x0a    self codeWidget model: aModel code.\x0a    \x0a    self \x0a        observeCodeWidget;\x0a    \x09observeVariablesWidget;\x0a        observeModel",
+messageSends: ["model:", "codeWidget", "code", "observeCodeWidget", "observeVariablesWidget", "observeModel"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeCodeWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDoItExecuted(){return globals.HLDoItExecuted||(typeof HLDoItExecuted=="undefined"?nil:HLDoItExecuted)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._codeWidget())._announcer())._on_do_($HLDoItExecuted(),(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._onDoneIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"observeCodeWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "observeCodeWidget\x0a\x09self codeWidget announcer \x0a    \x09on: HLDoItExecuted \x0a        do: [ self onDoneIt ]",
+messageSends: ["on:do:", "announcer", "codeWidget", "onDoneIt"],
+referencedClasses: ["HLDoItExecuted"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLInstanceVariableSelected(){return globals.HLInstanceVariableSelected||(typeof HLInstanceVariableSelected=="undefined"?nil:HLInstanceVariableSelected)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._model())._announcer())._on_send_to_($HLInstanceVariableSelected(),"onInstanceVariableSelected",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLInspectorWidget)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer\x0a        on: HLInstanceVariableSelected\x0a\x09\x09send: #onInstanceVariableSelected\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "model"],
+referencedClasses: ["HLInstanceVariableSelected"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeVariablesWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLDiveRequested(){return globals.HLDiveRequested||(typeof HLDiveRequested=="undefined"?nil:HLDiveRequested)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._variablesWidget())._announcer())._on_send_to_($HLDiveRequested(),"onDive",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeVariablesWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "observeVariablesWidget\x0a\x09self variablesWidget announcer \x0a        on: HLDiveRequested \x0a\x09\x09send: #onDive\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "variablesWidget"],
+referencedClasses: ["HLDiveRequested"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onDive",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+function $HLInspector(){return globals.HLInspector||(typeof HLInspector=="undefined"?nil:HLInspector)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLInspector())._new();
+_st($1)._inspect_(_st(self._model())._selectedInstVarObject());
+$2=_st($1)._openAsTab();
+return self}, function($ctx1) {$ctx1.fill(self,"onDive",{},globals.HLInspectorWidget)})},
+args: [],
+source: "onDive\x0a\x09HLInspector new \x0a\x09\x09inspect: self model selectedInstVarObject;\x0a\x09\x09openAsTab",
+messageSends: ["inspect:", "new", "selectedInstVarObject", "model", "openAsTab"],
+referencedClasses: ["HLInspector"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onDoneIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onDoneIt",{},globals.HLInspectorWidget)})},
+args: [],
+source: "onDoneIt\x0a\x0a\x09self refresh",
+messageSends: ["refresh"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onInspectIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "onInspectIt",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onInstanceVariableSelected",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._refreshDisplayWidget();
+return self}, function($ctx1) {$ctx1.fill(self,"onInstanceVariableSelected",{},globals.HLInspectorWidget)})},
+args: [],
+source: "onInstanceVariableSelected\x0a\x09self refreshDisplayWidget",
+messageSends: ["refreshDisplayWidget"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPrintIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "onPrintIt",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refresh",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._inspect_(self._inspectee());
+return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},globals.HLInspectorWidget)})},
+args: [],
+source: "refresh\x0a\x09self inspect: self inspectee",
+messageSends: ["inspect:", "inspectee"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refreshDisplayWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._displayWidget())._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"refreshDisplayWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "refreshDisplayWidget\x0a\x09self displayWidget refresh",
+messageSends: ["refresh", "displayWidget"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refreshVariablesWidget",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._variablesWidget())._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"refreshVariablesWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "refreshVariablesWidget\x0a\x09self variablesWidget refresh",
+messageSends: ["refresh", "variablesWidget"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "register",
+protocol: 'registration',
+fn: function (){
+var self=this;
+function $HLInspector(){return globals.HLInspector||(typeof HLInspector=="undefined"?nil:HLInspector)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLInspector())._register_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"register",{},globals.HLInspectorWidget)})},
+args: [],
+source: "register\x0a\x09HLInspector register: self",
+messageSends: ["register:"],
+referencedClasses: ["HLInspector"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLHorizontalSplitter())._with_with_(_st($HLVerticalSplitter())._with_with_(self._variablesWidget(),self._displayWidget()),self._codeWidget());
+$ctx1.sendIdx["with:with:"]=1;
+_st(html)._with_($1);
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLInspectorWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a   \x09html with: (HLHorizontalSplitter\x0a    \x09with: (HLVerticalSplitter \x0a            with: self variablesWidget\x0a            with: self displayWidget)\x0a        with: self codeWidget)",
+messageSends: ["with:", "with:with:", "variablesWidget", "displayWidget", "codeWidget"],
+referencedClasses: ["HLHorizontalSplitter", "HLVerticalSplitter"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setLabel:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._label_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"setLabel:",{aString:aString},globals.HLInspectorWidget)})},
+args: ["aString"],
+source: "setLabel: aString\x0a\x09self model label: aString",
+messageSends: ["label:", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setVariables:",
+protocol: 'actions',
+fn: function (aDictionary){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._variables_(aDictionary);
+return self}, function($ctx1) {$ctx1.fill(self,"setVariables:",{aDictionary:aDictionary},globals.HLInspectorWidget)})},
+args: ["aDictionary"],
+source: "setVariables: aDictionary\x0a\x09self model variables: aDictionary",
+messageSends: ["variables:", "model"],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Inspector";
+},
+args: [],
+source: "tabLabel\x0a    ^ 'Inspector'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'registration',
+fn: function (){
+var self=this;
+function $HLInspector(){return globals.HLInspector||(typeof HLInspector=="undefined"?nil:HLInspector)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLInspectorWidget.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+_st($HLInspector())._unregister_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLInspectorWidget)})},
+args: [],
+source: "unregister\x0a\x09super unregister.\x0a\x09HLInspector unregister: self",
+messageSends: ["unregister", "unregister:"],
+referencedClasses: ["HLInspector"]
+}),
+globals.HLInspectorWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variablesWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLInspectorVariablesWidget(){return globals.HLInspectorVariablesWidget||(typeof HLInspectorVariablesWidget=="undefined"?nil:HLInspectorVariablesWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@variablesWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLInspectorVariablesWidget())._new();
+_st($3)._inspector_(self);
+$4=_st($3)._yourself();
+self["@variablesWidget"]=$4;
+$1=self["@variablesWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"variablesWidget",{},globals.HLInspectorWidget)})},
+args: [],
+source: "variablesWidget\x0a\x09^ variablesWidget ifNil: [\x0a\x09\x09variablesWidget := HLInspectorVariablesWidget new\x0a    \x09\x09inspector: self;\x0a        \x09yourself ]",
+messageSends: ["ifNil:", "inspector:", "new", "yourself"],
+referencedClasses: ["HLInspectorVariablesWidget"]
+}),
+globals.HLInspectorWidget);
+
+
+
+smalltalk.addClass('HLInspector', globals.HLInspectorWidget, [], 'Helios-Inspector');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspect:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._setTabLabel_(_st(anObject)._printString());
+($ctx1.supercall = true, globals.HLInspector.superclass.fn.prototype._inspect_.apply(_st(self), [anObject]));
+$ctx1.supercall = false;
+return self}, function($ctx1) {$ctx1.fill(self,"inspect:",{anObject:anObject},globals.HLInspector)})},
+args: ["anObject"],
+source: "inspect: anObject\x0a\x09self setTabLabel: anObject printString.\x0a\x09super inspect: anObject",
+messageSends: ["setTabLabel:", "printString", "inspect:"],
+referencedClasses: []
+}),
+globals.HLInspector);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+var $4,$3,$2,$1;
+$4=self._variablesWidget();
+$ctx1.sendIdx["variablesWidget"]=1;
+$3=_st($HLVerticalSplitter())._with_with_($4,self._displayWidget());
+$2=_st($HLHorizontalSplitter())._with_with_($3,self._codeWidget());
+$ctx1.sendIdx["with:with:"]=1;
+$1=_st($HLContainer())._with_($2);
+_st(html)._with_($1);
+$ctx1.sendIdx["with:"]=1;
+_st(self._variablesWidget())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLInspector)})},
+args: ["html"],
+source: "renderContentOn: html\x0a   \x09html with: (HLContainer with: (HLHorizontalSplitter\x0a    \x09with: (HLVerticalSplitter \x0a            with: self variablesWidget\x0a            with: self displayWidget)\x0a        with: self codeWidget)).\x0a\x09\x0a\x09self variablesWidget focus",
+messageSends: ["with:", "with:with:", "variablesWidget", "displayWidget", "codeWidget", "focus"],
+referencedClasses: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"]
+}),
+globals.HLInspector);
+
+
+globals.HLInspector.klass.iVarNames = ['inspectors'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLInspector.klass.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._watchChanges();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLInspector.klass)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09self watchChanges",
+messageSends: ["initialize", "watchChanges"],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspect:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._new();
+_st($1)._openAsTab();
+$2=_st($1)._inspect_(anObject);
+return self}, function($ctx1) {$ctx1.fill(self,"inspect:",{anObject:anObject},globals.HLInspector.klass)})},
+args: ["anObject"],
+source: "inspect: anObject\x0a\x09self new\x0a\x09\x09openAsTab;\x0a\x09\x09inspect: anObject",
+messageSends: ["openAsTab", "new", "inspect:"],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectors",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@inspectors"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@inspectors"]=_st($OrderedCollection())._new();
+$1=self["@inspectors"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inspectors",{},globals.HLInspector.klass)})},
+args: [],
+source: "inspectors\x0a\x09^ inspectors ifNil: [ inspectors := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "register:",
+protocol: 'registration',
+fn: function (anInspector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._inspectors())._add_(anInspector);
+return self}, function($ctx1) {$ctx1.fill(self,"register:",{anInspector:anInspector},globals.HLInspector.klass)})},
+args: ["anInspector"],
+source: "register: anInspector\x0a\x09self inspectors add: anInspector",
+messageSends: ["add:", "inspectors"],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "inspector";
+},
+args: [],
+source: "tabClass\x0a\x09^ 'inspector'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Inspector";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'Inspector'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabPriority",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (10);
+},
+args: [],
+source: "tabPriority\x0a\x09^ 10",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister:",
+protocol: 'registration',
+fn: function (anInspector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._inspectors())._remove_(anInspector);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister:",{anInspector:anInspector},globals.HLInspector.klass)})},
+args: ["anInspector"],
+source: "unregister: anInspector\x0a\x09self inspectors remove: anInspector",
+messageSends: ["remove:", "inspectors"],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "watchChanges",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._inspectors())._do_((function(each){
+return smalltalk.withContext(function($ctx3) {
+return _st(each)._refresh();
+}, function($ctx3) {$ctx3.fillBlock({each:each},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._valueWithInterval_((500));
+return self}, function($ctx1) {$ctx1.fill(self,"watchChanges",{},globals.HLInspector.klass)})},
+args: [],
+source: "watchChanges\x0a\x09[ self inspectors do: [ :each | each refresh ] ]\x0a\x09\x09valueWithInterval: 500",
+messageSends: ["valueWithInterval:", "do:", "inspectors", "refresh"],
+referencedClasses: []
+}),
+globals.HLInspector.klass);
+
+});

src/Helios-Inspector.st

@@ -0,0 +1,452 @@
+Smalltalk createPackage: 'Helios-Inspector'!
+HLNavigationListWidget subclass: #HLInspectorDisplayWidget
+	instanceVariableNames: 'inspector'
+	package: 'Helios-Inspector'!
+
+!HLInspectorDisplayWidget methodsFor: 'accessing'!
+
+inspector
+	^ inspector
+!
+
+inspector: anInspector
+	inspector := anInspector
+!
+
+model
+
+	^ self inspector model
+! !
+
+!HLInspectorDisplayWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+	
+    html div with: self selectionDisplayString
+!
+
+selectionDisplayString
+	|selection|
+	selection := self model selection.
+    ^ (self model variables includesKey: selection)
+    	ifTrue:[ (self model instVarObjectAt: selection) printString ]
+      	ifFalse:[ '' ]
+! !
+
+HLModel subclass: #HLInspectorModel
+	instanceVariableNames: 'inspectee code variables label selection'
+	package: 'Helios-Inspector'!
+!HLInspectorModel commentStamp!
+I am the model of the Helios inspector `HLInspectorWidget`.
+
+## API
+
+Use the method `inspect:on:` to inspect an object on an inspector.!
+
+!HLInspectorModel methodsFor: 'accessing'!
+
+code
+	"Answers the code model working for this workspace model"
+	^ code ifNil:[ code := HLCodeModel on: self environment ]
+!
+
+inspectee 
+	^ inspectee
+!
+
+inspectee: anObject 
+	inspectee := anObject
+!
+
+label
+    ^ label ifNil: [ self inspectee printString ]
+!
+
+label: aString
+    label := aString
+!
+
+selectedInstVarObject
+	^ self instVarObjectAt: self selection
+!
+
+selection
+	^ selection ifNil:[ '' ]
+!
+
+selection: anObject
+	selection := anObject.
+
+	self announcer announce: (HLInstanceVariableSelected on: selection)
+!
+
+variables
+	^ variables ifNil: [ Dictionary new ]
+!
+
+variables: aCollection
+	variables := aCollection
+! !
+
+!HLInspectorModel methodsFor: 'actions'!
+
+inspect: anObject on: anInspector
+	inspectee := anObject.
+	variables := #().
+	inspectee inspectOn: anInspector
+!
+
+instVarObjectAt: anInstVarName
+	^ self variables at: anInstVarName
+!
+
+selectedInstVar: anInstVarName
+    self selection: anInstVarName
+!
+
+subscribe: aWidget
+	aWidget subscribeTo: self announcer
+! !
+
+!HLInspectorModel class methodsFor: 'actions'!
+
+on: anEnvironment
+
+	^ self new
+    	environment: anEnvironment;
+        yourself
+! !
+
+HLNavigationListWidget subclass: #HLInspectorVariablesWidget
+	instanceVariableNames: 'announcer inspector list diveButton'
+	package: 'Helios-Inspector'!
+
+!HLInspectorVariablesWidget methodsFor: 'accessing'!
+
+announcer
+	^ announcer ifNil:[ announcer := Announcer new ]
+!
+
+inspector
+	^ inspector
+!
+
+inspector: anInspector
+	inspector := anInspector
+!
+
+label
+	^ self model label
+!
+
+model
+    ^ self inspector model
+!
+
+selection
+	^ self model selection
+!
+
+variables
+	^ self model variables keys
+! !
+
+!HLInspectorVariablesWidget methodsFor: 'actions'!
+
+dive
+	self announcer announce: HLDiveRequested new
+!
+
+refresh
+	self variables = self items ifFalse: [
+		self resetItems.
+    	super refresh ]
+!
+
+resetItems
+	items := nil
+! !
+
+!HLInspectorVariablesWidget methodsFor: 'defaults'!
+
+defaultItems
+	^ self variables
+! !
+
+!HLInspectorVariablesWidget methodsFor: 'reactions'!
+
+selectItem: anObject
+	super selectItem: anObject.
+    self model selectedInstVar: anObject
+! !
+
+!HLInspectorVariablesWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	diveButton := html button 
+		class: 'btn';
+		with: 'Dive'; 
+		onClick: [ self dive ]
+!
+
+renderContentOn: html
+	self renderHeadOn: html.
+	super renderContentOn: html.
+	self wrapper onDblClick: [ self dive ]
+!
+
+renderHeadOn: html
+	html div 
+		class: 'list-label';
+		with: self label
+! !
+
+HLWidget subclass: #HLInspectorWidget
+	instanceVariableNames: 'model variablesWidget displayWidget codeWidget'
+	package: 'Helios-Inspector'!
+
+!HLInspectorWidget methodsFor: 'accessing'!
+
+codeWidget
+	^ codeWidget ifNil: [
+		codeWidget := self defaultCodeWidget ]
+!
+
+codeWidget: aWidget
+	codeWidget := aWidget
+!
+
+displayWidget
+	^ displayWidget ifNil: [
+		displayWidget := HLInspectorDisplayWidget new
+    		inspector: self;
+        	yourself ]
+!
+
+initialize
+	super initialize.
+	self register
+!
+
+inspectee
+	^ self model inspectee
+!
+
+inspectee: anObject
+	self model inspectee: anObject
+!
+
+label
+    ^ self model label
+!
+
+model
+	^ model ifNil: [ 
+    	self model: HLInspectorModel new.
+		model ]
+!
+
+model: aModel
+	model := aModel. 
+    self codeWidget model: aModel code.
+    
+    self 
+        observeCodeWidget;
+    	observeVariablesWidget;
+        observeModel
+!
+
+tabLabel
+    ^ 'Inspector'
+!
+
+variablesWidget
+	^ variablesWidget ifNil: [
+		variablesWidget := HLInspectorVariablesWidget new
+    		inspector: self;
+        	yourself ]
+! !
+
+!HLInspectorWidget methodsFor: 'actions'!
+
+inspect: anObject
+	self model inspect: anObject on: self.
+	self codeWidget receiver: anObject.
+    
+	self 
+    	refreshVariablesWidget;
+		refreshDisplayWidget
+!
+
+observeCodeWidget
+	self codeWidget announcer 
+    	on: HLDoItExecuted 
+        do: [ self onDoneIt ]
+!
+
+observeModel
+	self model announcer
+        on: HLInstanceVariableSelected
+		send: #onInstanceVariableSelected
+		to: self
+!
+
+observeVariablesWidget
+	self variablesWidget announcer 
+        on: HLDiveRequested 
+		send: #onDive
+		to: self
+!
+
+refresh
+	self inspect: self inspectee
+!
+
+refreshDisplayWidget
+	self displayWidget refresh
+!
+
+refreshVariablesWidget
+	self variablesWidget refresh
+!
+
+setLabel: aString
+	self model label: aString
+!
+
+setVariables: aDictionary
+	self model variables: aDictionary
+! !
+
+!HLInspectorWidget methodsFor: 'defaults'!
+
+defaultCodeWidget
+	^ HLCodeWidget new
+    	model: self model code;
+       	receiver: self model inspectee;
+       	yourself
+! !
+
+!HLInspectorWidget methodsFor: 'reactions'!
+
+onDive
+	HLInspector new 
+		inspect: self model selectedInstVarObject;
+		openAsTab
+!
+
+onDoneIt
+
+	self refresh
+!
+
+onInspectIt
+!
+
+onInstanceVariableSelected
+	self refreshDisplayWidget
+!
+
+onPrintIt
+! !
+
+!HLInspectorWidget methodsFor: 'registration'!
+
+register
+	HLInspector register: self
+!
+
+unregister
+	super unregister.
+	HLInspector unregister: self
+! !
+
+!HLInspectorWidget methodsFor: 'rendering'!
+
+renderContentOn: html
+   	html with: (HLHorizontalSplitter
+    	with: (HLVerticalSplitter 
+            with: self variablesWidget
+            with: self displayWidget)
+        with: self codeWidget)
+! !
+
+HLInspectorWidget subclass: #HLInspector
+	instanceVariableNames: ''
+	package: 'Helios-Inspector'!
+
+!HLInspector methodsFor: 'actions'!
+
+inspect: anObject
+	self setTabLabel: anObject printString.
+	super inspect: anObject
+! !
+
+!HLInspector methodsFor: 'rendering'!
+
+renderContentOn: html
+   	html with: (HLContainer with: (HLHorizontalSplitter
+    	with: (HLVerticalSplitter 
+            with: self variablesWidget
+            with: self displayWidget)
+        with: self codeWidget)).
+	
+	self variablesWidget focus
+! !
+
+HLInspector class instanceVariableNames: 'inspectors'!
+
+!HLInspector class methodsFor: 'accessing'!
+
+inspectors
+	^ inspectors ifNil: [ inspectors := OrderedCollection new ]
+!
+
+tabClass
+	^ 'inspector'
+!
+
+tabLabel
+	^ 'Inspector'
+!
+
+tabPriority
+	^ 10
+! !
+
+!HLInspector class methodsFor: 'actions'!
+
+inspect: anObject
+	self new
+		openAsTab;
+		inspect: anObject
+! !
+
+!HLInspector class methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	self watchChanges
+!
+
+watchChanges
+	[ self inspectors do: [ :each | each refresh ] ]
+		valueWithInterval: 500
+! !
+
+!HLInspector class methodsFor: 'registration'!
+
+register: anInspector
+	self inspectors add: anInspector
+!
+
+unregister: anInspector
+	self inspectors remove: anInspector
+! !
+
+!HLInspector class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ false
+! !
+

src/Helios-KeyBindings.js

@@ -0,0 +1,2280 @@
+define("helios/Helios-KeyBindings", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "helios/Helios-Core"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-KeyBindings');
+smalltalk.packages["Helios-KeyBindings"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLBinding', globals.Object, ['key', 'label'], 'Helios-KeyBindings');
+globals.HLBinding.comment="I am the abstract representation of a keybinding in Helios. My instances hold a key (integer value) and a label. \x0a\x0aBindings are built into a tree of keys, so pressing a key may result in more key choices (for example, to open a workspace, 'o' is pressed first then 'w' is pressed).\x0a\x0aBinding action handling and selection is handled by the `current` instance of `HLKeyBinder`.\x0a\x0aSubclasses implement specific behavior like evaluating actions or (sub-)grouping other bindings.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "apply",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "apply",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "atKey:",
+protocol: 'accessing',
+fn: function (aKey){
+var self=this;
+return nil;
+},
+args: ["aKey"],
+source: "atKey: aKey\x0a\x09\x22Answer the sub-binding at key aKey.\x0a\x09Always answer nil here. See HLBindingGroup for more.\x22\x0a\x09\x0a\x09^ nil",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._label();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"displayLabel",{},globals.HLBinding)})},
+args: [],
+source: "displayLabel\x0a\x09^ self label",
+messageSends: ["label"],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._subclassResponsibility();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLBinding)})},
+args: [],
+source: "isActive\x0a\x09^ self subclassResponsibility",
+messageSends: ["subclassResponsibility"],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@key"];
+return $1;
+},
+args: [],
+source: "key\x0a\x09^ key",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+self["@key"]=anInteger;
+return self},
+args: ["anInteger"],
+source: "key: anInteger\x0a\x09key := anInteger",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@label"];
+return $1;
+},
+args: [],
+source: "label\x0a\x09^ label",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@label"]=aString;
+return self},
+args: ["aString"],
+source: "label: aString\x0a\x09label := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "release",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "release",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:html:",
+protocol: 'rendering',
+fn: function (aBindingHelper,html){
+var self=this;
+return self},
+args: ["aBindingHelper", "html"],
+source: "renderOn: aBindingHelper html: html",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBinding);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "shortcut",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($String())._fromCharCode_(self._key());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"shortcut",{},globals.HLBinding)})},
+args: [],
+source: "shortcut\x0a\x09^ String fromCharCode: self key",
+messageSends: ["fromCharCode:", "key"],
+referencedClasses: ["String"]
+}),
+globals.HLBinding);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:labelled:",
+protocol: 'instance creation',
+fn: function (anInteger,aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._key_(anInteger);
+_st($2)._label_(aString);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:labelled:",{anInteger:anInteger,aString:aString},globals.HLBinding.klass)})},
+args: ["anInteger", "aString"],
+source: "on: anInteger labelled: aString\x0a\x09^ self new\x0a    \x09key: anInteger;\x0a        label: aString;\x0a        yourself",
+messageSends: ["key:", "new", "label:", "yourself"],
+referencedClasses: []
+}),
+globals.HLBinding.klass);
+
+
+smalltalk.addClass('HLBindingAction', globals.HLBinding, ['command'], 'Helios-KeyBindings');
+globals.HLBindingAction.comment="My instances are the leafs of the binding tree. They evaluate actions through commands, instances of concrete subclasses of `HLCommand`.\x0a\x0aThe `#apply` methods is used to evaluate the `command`. If the command requires user input, an `inputWidget` will be displayed to the user.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "apply",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLKeyBinder(){return globals.HLKeyBinder||(typeof HLKeyBinder=="undefined"?nil:HLKeyBinder)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._command())._isInputRequired();
+if(smalltalk.assert($1)){
+_st(_st(_st($HLKeyBinder())._current())._helper())._showWidget_(self._inputWidget());
+} else {
+self._executeCommand();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"apply",{},globals.HLBindingAction)})},
+args: [],
+source: "apply\x0a\x09self command isInputRequired\x0a\x09\x09ifTrue: [ HLKeyBinder current helper showWidget: self inputWidget ]\x0a\x09\x09ifFalse: [ self executeCommand ]",
+messageSends: ["ifTrue:ifFalse:", "isInputRequired", "command", "showWidget:", "helper", "current", "inputWidget", "executeCommand"],
+referencedClasses: ["HLKeyBinder"]
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "command",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@command"];
+return $1;
+},
+args: [],
+source: "command\x0a\x09^ command",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "command:",
+protocol: 'accessing',
+fn: function (aCommand){
+var self=this;
+self["@command"]=aCommand;
+return self},
+args: ["aCommand"],
+source: "command: aCommand\x0a\x09command := aCommand",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "executeCommand",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLKeyBinder(){return globals.HLKeyBinder||(typeof HLKeyBinder=="undefined"?nil:HLKeyBinder)}
+return smalltalk.withContext(function($ctx1) { 
+_st(self._command())._execute();
+_st(_st($HLKeyBinder())._current())._deactivate();
+return self}, function($ctx1) {$ctx1.fill(self,"executeCommand",{},globals.HLBindingAction)})},
+args: [],
+source: "executeCommand\x0a\x09self command execute.\x0a\x09HLKeyBinder current deactivate",
+messageSends: ["execute", "command", "deactivate", "current"],
+referencedClasses: ["HLKeyBinder"]
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "input:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._command())._input_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"input:",{aString:aString},globals.HLBindingAction)})},
+args: ["aString"],
+source: "input: aString\x0a\x09self command input: aString",
+messageSends: ["input:", "command"],
+referencedClasses: []
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputBinding",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLBindingInput(){return globals.HLBindingInput||(typeof HLBindingInput=="undefined"?nil:HLBindingInput)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$5,$4,$6,$8,$7,$9,$11,$10,$12,$14,$13,$15,$16,$17,$1;
+$2=_st($HLBindingInput())._new();
+$3=$2;
+$5=self._command();
+$ctx1.sendIdx["command"]=1;
+$4=_st($5)._inputLabel();
+_st($3)._label_($4);
+$6=$2;
+$8=self._command();
+$ctx1.sendIdx["command"]=2;
+$7=_st($8)._displayLabel();
+_st($6)._ghostText_($7);
+$9=$2;
+$11=self._command();
+$ctx1.sendIdx["command"]=3;
+$10=_st($11)._defaultInput();
+_st($9)._defaultValue_($10);
+$12=$2;
+$14=self._command();
+$ctx1.sendIdx["command"]=4;
+$13=_st($14)._inputCompletion();
+_st($12)._inputCompletion_($13);
+_st($2)._callback_((function(val){
+return smalltalk.withContext(function($ctx2) {
+$15=self._command();
+_st($15)._input_(val);
+$16=_st($15)._execute();
+return $16;
+}, function($ctx2) {$ctx2.fillBlock({val:val},$ctx1,1)})}));
+$17=_st($2)._yourself();
+$1=$17;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputBinding",{},globals.HLBindingAction)})},
+args: [],
+source: "inputBinding\x0a\x09^ HLBindingInput new\x0a\x09\x09label: self command inputLabel;\x0a\x09\x09ghostText: self command displayLabel;\x0a\x09\x09defaultValue: self command defaultInput;\x0a\x09\x09inputCompletion: self command inputCompletion;\x0a\x09\x09callback: [ :val | \x0a\x09\x09\x09self command \x0a\x09\x09\x09\x09input: val;\x0a\x09\x09\x09\x09execute ];\x0a\x09\x09yourself",
+messageSends: ["label:", "new", "inputLabel", "command", "ghostText:", "displayLabel", "defaultValue:", "defaultInput", "inputCompletion:", "inputCompletion", "callback:", "input:", "execute", "yourself"],
+referencedClasses: ["HLBindingInput"]
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLBindingActionInputWidget(){return globals.HLBindingActionInputWidget||(typeof HLBindingActionInputWidget=="undefined"?nil:HLBindingActionInputWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$5,$4,$6,$8,$7,$9,$10,$1;
+$2=_st($HLBindingActionInputWidget())._new();
+$3=$2;
+$5=self._command();
+$ctx1.sendIdx["command"]=1;
+$4=_st($5)._displayLabel();
+_st($3)._ghostText_($4);
+$6=$2;
+$8=self._command();
+$ctx1.sendIdx["command"]=2;
+$7=_st($8)._defaultInput();
+_st($6)._defaultValue_($7);
+_st($2)._inputCompletion_(_st(self._command())._inputCompletion());
+_st($2)._callback_((function(value){
+return smalltalk.withContext(function($ctx2) {
+self._input_(value);
+$9=self._executeCommand();
+return $9;
+}, function($ctx2) {$ctx2.fillBlock({value:value},$ctx1,1)})}));
+$10=_st($2)._yourself();
+$1=$10;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputWidget",{},globals.HLBindingAction)})},
+args: [],
+source: "inputWidget\x0a\x09^ HLBindingActionInputWidget new\x0a\x09\x09ghostText: self command displayLabel;\x0a\x09\x09defaultValue: self command defaultInput;\x0a\x09\x09inputCompletion: self command inputCompletion;\x0a\x09\x09callback: [ :value | \x0a\x09\x09\x09self \x0a\x09\x09\x09\x09input: value;\x0a\x09\x09\x09\x09executeCommand ];\x0a\x09\x09yourself",
+messageSends: ["ghostText:", "new", "displayLabel", "command", "defaultValue:", "defaultInput", "inputCompletion:", "inputCompletion", "callback:", "input:", "executeCommand", "yourself"],
+referencedClasses: ["HLBindingActionInputWidget"]
+}),
+globals.HLBindingAction);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._command())._isActive();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLBindingAction)})},
+args: [],
+source: "isActive\x0a\x09^ self command isActive",
+messageSends: ["isActive", "command"],
+referencedClasses: []
+}),
+globals.HLBindingAction);
+
+
+
+smalltalk.addClass('HLBindingGroup', globals.HLBinding, ['bindings'], 'Helios-KeyBindings');
+globals.HLBindingGroup.comment="My instances hold other bindings, either actions or groups, and do not have actions by themselves.\x0a\x0aChildren are accessed with `atKey:` and added with the `add*` methods.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activeBindings",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._bindings())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._isActive();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"activeBindings",{},globals.HLBindingGroup)})},
+args: [],
+source: "activeBindings\x0a\x09^ self bindings select: [ :each | each isActive ]",
+messageSends: ["select:", "bindings", "isActive"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "add:",
+protocol: 'adding',
+fn: function (aBinding){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._bindings())._add_(aBinding);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"add:",{aBinding:aBinding},globals.HLBindingGroup)})},
+args: ["aBinding"],
+source: "add: aBinding\x0a\x09^ self bindings add: aBinding",
+messageSends: ["add:", "bindings"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addActionKey:labelled:callback:",
+protocol: 'adding',
+fn: function (anInteger,aString,aBlock){
+var self=this;
+function $HLBindingAction(){return globals.HLBindingAction||(typeof HLBindingAction=="undefined"?nil:HLBindingAction)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st($HLBindingAction())._on_labelled_(anInteger,aString);
+_st($1)._callback_(aBlock);
+$2=_st($1)._yourself();
+self._add_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"addActionKey:labelled:callback:",{anInteger:anInteger,aString:aString,aBlock:aBlock},globals.HLBindingGroup)})},
+args: ["anInteger", "aString", "aBlock"],
+source: "addActionKey: anInteger labelled: aString callback: aBlock\x0a\x09self add: ((HLBindingAction on: anInteger labelled: aString)\x0a    \x09callback: aBlock;\x0a        yourself)",
+messageSends: ["add:", "callback:", "on:labelled:", "yourself"],
+referencedClasses: ["HLBindingAction"]
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "addGroupKey:labelled:",
+protocol: 'add',
+fn: function (anInteger,aString){
+var self=this;
+function $HLBindingGroup(){return globals.HLBindingGroup||(typeof HLBindingGroup=="undefined"?nil:HLBindingGroup)}
+return smalltalk.withContext(function($ctx1) { 
+self._add_(_st($HLBindingGroup())._on_labelled_(anInteger,aString));
+return self}, function($ctx1) {$ctx1.fill(self,"addGroupKey:labelled:",{anInteger:anInteger,aString:aString},globals.HLBindingGroup)})},
+args: ["anInteger", "aString"],
+source: "addGroupKey: anInteger labelled: aString\x0a\x09self add: (HLBindingGroup on: anInteger labelled: aString)",
+messageSends: ["add:", "on:labelled:"],
+referencedClasses: ["HLBindingGroup"]
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "at:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._bindings())._detect_ifNone_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._label()).__eq(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){
+return nil;
+}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"at:",{aString:aString},globals.HLBindingGroup)})},
+args: ["aString"],
+source: "at: aString\x0a\x09^ self bindings \x0a    \x09detect: [ :each | each label = aString ]\x0a      \x09ifNone: [ nil ]",
+messageSends: ["detect:ifNone:", "bindings", "=", "label"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "at:add:",
+protocol: 'accessing',
+fn: function (aString,aBinding){
+var self=this;
+var binding;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+binding=self._at_(aString);
+$1=binding;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+_st(binding)._add_(aBinding);
+return self}, function($ctx1) {$ctx1.fill(self,"at:add:",{aString:aString,aBinding:aBinding,binding:binding},globals.HLBindingGroup)})},
+args: ["aString", "aBinding"],
+source: "at: aString add: aBinding\x0a\x09| binding |\x0a\x09\x0a\x09binding := self at: aString.\x0a\x09binding ifNil: [ ^ self ].\x0a\x09\x09\x0a\x09binding add: aBinding",
+messageSends: ["at:", "ifNil:", "add:"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "atKey:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._bindings())._detect_ifNone_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._key()).__eq(anInteger);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){
+return nil;
+}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"atKey:",{anInteger:anInteger},globals.HLBindingGroup)})},
+args: ["anInteger"],
+source: "atKey: anInteger\x0a\x09^ self bindings \x0a    \x09detect: [ :each | each key = anInteger ]\x0a      \x09ifNone: [ nil ]",
+messageSends: ["detect:ifNone:", "bindings", "=", "key"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "bindings",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@bindings"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@bindings"]=_st($OrderedCollection())._new();
+$1=self["@bindings"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"bindings",{},globals.HLBindingGroup)})},
+args: [],
+source: "bindings\x0a\x09^ bindings ifNil: [ bindings := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "displayLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=($ctx1.supercall = true, globals.HLBindingGroup.superclass.fn.prototype._displayLabel.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st($2).__comma("...");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"displayLabel",{},globals.HLBindingGroup)})},
+args: [],
+source: "displayLabel\x0a\x09^ super displayLabel, '...'",
+messageSends: [",", "displayLabel"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._activeBindings())._notEmpty();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLBindingGroup)})},
+args: [],
+source: "isActive\x0a\x09^ self activeBindings notEmpty",
+messageSends: ["notEmpty", "activeBindings"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "release",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._bindings())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._release();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"release",{},globals.HLBindingGroup)})},
+args: [],
+source: "release\x0a\x09self bindings do: [ :each | each release ]",
+messageSends: ["do:", "bindings", "release"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:html:",
+protocol: 'rendering',
+fn: function (aBindingHelper,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._isActive();
+if(smalltalk.assert($1)){
+_st(aBindingHelper)._renderBindingGroup_on_(self,html);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:html:",{aBindingHelper:aBindingHelper,html:html},globals.HLBindingGroup)})},
+args: ["aBindingHelper", "html"],
+source: "renderOn: aBindingHelper html: html\x0a\x09self isActive ifTrue: [\x0a\x09\x09aBindingHelper renderBindingGroup: self on: html ]",
+messageSends: ["ifTrue:", "isActive", "renderBindingGroup:on:"],
+referencedClasses: []
+}),
+globals.HLBindingGroup);
+
+
+
+smalltalk.addClass('HLBindingActionInputWidget', globals.HLWidget, ['input', 'callback', 'status', 'wrapper', 'ghostText', 'message', 'inputCompletion', 'defaultValue', 'messageTag'], 'Helios-KeyBindings');
+globals.HLBindingActionInputWidget.comment="My instances are built when a `HLBindingAction` that requires user input is applied.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "callback",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@callback"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@callback"]=(function(value){
+});
+$1=self["@callback"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"callback",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "callback\x0a\x09^ callback ifNil: [ callback := [ :value | ] ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "callback:",
+protocol: 'accessing',
+fn: function (aBlock){
+var self=this;
+self["@callback"]=aBlock;
+return self},
+args: ["aBlock"],
+source: "callback: aBlock\x0a\x09callback := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "clearStatus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._status_("info");
+self._message_("");
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"clearStatus",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "clearStatus\x0a\x09self status: 'info'.\x0a\x09self message: ''.\x0a\x09self refresh",
+messageSends: ["status:", "message:", "refresh"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultValue",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@defaultValue"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultValue",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "defaultValue\x0a\x09^ defaultValue ifNil: [ '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultValue:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@defaultValue"]=aString;
+return self},
+args: ["aString"],
+source: "defaultValue: aString\x0a\x09defaultValue := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "errorStatus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._status_("error");
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"errorStatus",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "errorStatus\x0a\x09self status: 'error'.\x0a\x09self refresh",
+messageSends: ["status:", "refresh"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "evaluate:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+return smalltalk.withContext(function($ctx1) { 
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._callback())._value_(aString);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._on_do_($Error(),(function(ex){
+return smalltalk.withContext(function($ctx2) {
+_st(_st(self._input())._asJQuery())._one_do_("keydown",(function(){
+return smalltalk.withContext(function($ctx3) {
+return self._clearStatus();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+self._message_(_st(ex)._messageText());
+return self._errorStatus();
+}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"evaluate:",{aString:aString},globals.HLBindingActionInputWidget)})},
+args: ["aString"],
+source: "evaluate: aString\x09\x0a\x09[ self callback value: aString ]\x0a\x09\x09on: Error\x0a\x09\x09do: [ :ex |\x0a\x09\x09\x09self input asJQuery \x0a\x09\x09\x09\x09one: 'keydown' \x0a\x09\x09\x09\x09do: [ self clearStatus ].\x0a\x09\x09\x09self message: ex messageText.\x0a\x09\x09\x09self errorStatus ]",
+messageSends: ["on:do:", "value:", "callback", "one:do:", "asJQuery", "input", "clearStatus", "message:", "messageText", "errorStatus"],
+referencedClasses: ["Error"]
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "ghostText",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@ghostText"];
+return $1;
+},
+args: [],
+source: "ghostText\x0a\x09^ ghostText",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "ghostText:",
+protocol: 'accessing',
+fn: function (aText){
+var self=this;
+self["@ghostText"]=aText;
+return self},
+args: ["aText"],
+source: "ghostText: aText\x0a\x09ghostText := aText",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "input",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@input"];
+return $1;
+},
+args: [],
+source: "input\x0a\x09^ input",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@inputCompletion"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=[];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "inputCompletion\x0a\x09^ inputCompletion ifNil: [ #() ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inputCompletion:",
+protocol: 'accessing',
+fn: function (aCollection){
+var self=this;
+self["@inputCompletion"]=aCollection;
+return self},
+args: ["aCollection"],
+source: "inputCompletion: aCollection\x0a\x09inputCompletion := aCollection",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "message",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@message"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@message"]="";
+$1=self["@message"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"message",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "message\x0a\x09^ message ifNil: [ message := '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "message:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@message"]=aString;
+return self},
+args: ["aString"],
+source: "message: aString\x0a\x09message := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refresh",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self["@wrapper"];
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+_st(self["@wrapper"])._class_(self._status());
+_st(self["@messageTag"])._contents_(self._message());
+return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "refresh\x0a\x09wrapper ifNil: [ ^ self ].\x0a    \x0a\x09wrapper class: self status.\x0a\x09messageTag contents: self message",
+messageSends: ["ifNil:", "class:", "status", "contents:", "message"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$6,$8,$10,$9,$7,$5,$11,$12,$13,$3,$14,$15,$receiver;
+$1=self["@wrapper"];
+if(($receiver = $1) == null || $receiver.isNil){
+self["@wrapper"]=_st(html)._span();
+$ctx1.sendIdx["span"]=1;
+self["@wrapper"];
+} else {
+$1;
+};
+$2=self["@wrapper"];
+_st($2)._class_(self._status());
+$ctx1.sendIdx["class:"]=1;
+$3=_st($2)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(html)._input();
+_st($4)._placeholder_(self._ghostText());
+_st($4)._value_(self._defaultValue());
+$6=$4;
+$7=_st((function(event){
+return smalltalk.withContext(function($ctx3) {
+$8=_st(_st(event)._which()).__eq((13));
+if(smalltalk.assert($8)){
+$10=_st(self["@input"])._asJQuery();
+$ctx3.sendIdx["asJQuery"]=1;
+$9=_st($10)._val();
+return self._evaluate_($9);
+};
+}, function($ctx3) {$ctx3.fillBlock({event:event},$ctx2,3)})}))._yourself();
+$ctx2.sendIdx["yourself"]=1;
+$5=_st($6)._onKeyDown_($7);
+self["@input"]=$5;
+self["@input"];
+$11=_st(self["@input"])._asJQuery();
+$ctx2.sendIdx["asJQuery"]=2;
+_st($11)._typeahead_(globals.HashedCollection._newFromPairs_(["source",self._inputCompletion()]));
+$12=_st(html)._span();
+_st($12)._class_("help-inline");
+_st($12)._with_(self._message());
+$13=_st($12)._yourself();
+self["@messageTag"]=$13;
+return self["@messageTag"];
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$ctx1.sendIdx["with:"]=1;
+_st((function(){
+return smalltalk.withContext(function($ctx2) {
+$14=_st(self["@input"])._asJQuery();
+_st($14)._focus();
+$15=_st($14)._select();
+return $15;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,5)})}))._valueWithTimeout_((10));
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLBindingActionInputWidget)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09wrapper ifNil: [ wrapper := html span ].\x0a\x0a\x09wrapper \x0a\x09\x09class: self status;\x0a\x09\x09with: [\x0a\x09\x09\x09input := html input\x0a\x09\x09\x09\x09placeholder: self ghostText;\x0a\x09\x09\x09\x09value: self defaultValue;\x0a\x09\x09\x09\x09onKeyDown: [ :event | \x0a\x09\x09\x09\x09\x09event which = 13 ifTrue: [\x0a\x09\x09\x09\x09\x09\x09self evaluate: input asJQuery val ] ]\x0a\x09\x09\x09\x09yourself.\x0a\x09\x09\x09input asJQuery \x0a\x09\x09\x09\x09typeahead: #{ 'source' -> self inputCompletion }.\x0a\x09\x09\x09messageTag := (html span\x0a\x09\x09\x09\x09class: 'help-inline';\x0a\x09\x09\x09\x09with: self message;\x0a\x09\x09\x09\x09yourself) ].\x0a\x09\x0a\x09\x22Evaluate with a timeout to ensure focus.\x0a\x09Commands can be executed from a menu, clicking on the menu to\x0a\x09evaluate the command would give it the focus otherwise\x22\x0a\x09\x0a\x09[ input asJQuery focus; select ] valueWithTimeout: 10",
+messageSends: ["ifNil:", "span", "class:", "status", "with:", "placeholder:", "input", "ghostText", "value:", "defaultValue", "onKeyDown:", "yourself", "ifTrue:", "=", "which", "evaluate:", "val", "asJQuery", "typeahead:", "inputCompletion", "message", "valueWithTimeout:", "focus", "select"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "status",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@status"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@status"]="info";
+$1=self["@status"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"status",{},globals.HLBindingActionInputWidget)})},
+args: [],
+source: "status\x0a\x09^ status ifNil: [ status := 'info' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "status:",
+protocol: 'accessing',
+fn: function (aStatus){
+var self=this;
+self["@status"]=aStatus;
+return self},
+args: ["aStatus"],
+source: "status: aStatus\x0a\x09status := aStatus",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBindingActionInputWidget);
+
+
+
+smalltalk.addClass('HLKeyBinder', globals.Object, ['modifierKey', 'helper', 'bindings', 'selectedBinding'], 'Helios-KeyBindings');
+globals.HLKeyBinder.comment="My `current` instance holds keybindings for Helios actions and evaluate them.\x0a\x0aBindings can be nested by groups. The `bindings` instance variable holds the root of the key bindings tree.\x0a\x0aBindings are instances of a concrete subclass of `HLBinding`.\x0a\x0aI am always either in 'active' or 'inactive' state. In active state I capture key down events and my `helper` widget is displayed at the bottom of the window. My `selectedBinding`, if any, is displayed by the helper.\x0a\x0aBindings are evaluated through `applyBinding:`. If a binding is final (not a group of other bindings), evaluating it will result in deactivating the binder, and hiding the `helper` widget.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activate",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._helper())._show();
+return self}, function($ctx1) {$ctx1.fill(self,"activate",{},globals.HLKeyBinder)})},
+args: [],
+source: "activate\x0a\x09self helper show",
+messageSends: ["show", "helper"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activationKey",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (32);
+},
+args: [],
+source: "activationKey\x0a\x09\x22SPACE\x22\x0a\x09^ 32",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activationKeyLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "ctrl + space";
+},
+args: [],
+source: "activationKeyLabel\x0a\x09^ 'ctrl + space'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "applyBinding:",
+protocol: 'actions',
+fn: function (aBinding){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aBinding)._isActive();
+if(! smalltalk.assert($1)){
+return self;
+};
+self._selectBinding_(aBinding);
+_st(aBinding)._apply();
+return self}, function($ctx1) {$ctx1.fill(self,"applyBinding:",{aBinding:aBinding},globals.HLKeyBinder)})},
+args: ["aBinding"],
+source: "applyBinding: aBinding\x0a\x09aBinding isActive ifFalse: [ ^ self ].\x0a\x09\x0a\x09self selectBinding: aBinding.\x0a    aBinding apply",
+messageSends: ["ifFalse:", "isActive", "selectBinding:", "apply"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "bindings",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@bindings"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@bindings"]=self._defaultBindings();
+$1=self["@bindings"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"bindings",{},globals.HLKeyBinder)})},
+args: [],
+source: "bindings\x0a\x09^ bindings ifNil: [ bindings := self defaultBindings ]",
+messageSends: ["ifNil:", "defaultBindings"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "deactivate",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self["@selectedBinding"];
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+_st(self["@selectedBinding"])._release();
+};
+self["@selectedBinding"]=nil;
+_st(self._helper())._hide();
+return self}, function($ctx1) {$ctx1.fill(self,"deactivate",{},globals.HLKeyBinder)})},
+args: [],
+source: "deactivate\x0a\x09selectedBinding ifNotNil: [ selectedBinding release ].\x0a    selectedBinding := nil.\x0a\x09self helper hide",
+messageSends: ["ifNotNil:", "release", "hide", "helper"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultBindings",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+var group;
+function $HLBindingGroup(){return globals.HLBindingGroup||(typeof HLBindingGroup=="undefined"?nil:HLBindingGroup)}
+function $HLCloseTabCommand(){return globals.HLCloseTabCommand||(typeof HLCloseTabCommand=="undefined"?nil:HLCloseTabCommand)}
+function $HLSwitchTabCommand(){return globals.HLSwitchTabCommand||(typeof HLSwitchTabCommand=="undefined"?nil:HLSwitchTabCommand)}
+function $HLOpenCommand(){return globals.HLOpenCommand||(typeof HLOpenCommand=="undefined"?nil:HLOpenCommand)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$5,$6;
+$1=_st($HLBindingGroup())._new();
+$ctx1.sendIdx["new"]=1;
+$2=$1;
+$4=_st($HLCloseTabCommand())._new();
+$ctx1.sendIdx["new"]=2;
+$3=_st($4)._asBinding();
+$ctx1.sendIdx["asBinding"]=1;
+_st($2)._add_($3);
+$ctx1.sendIdx["add:"]=1;
+_st($1)._add_(_st(_st($HLSwitchTabCommand())._new())._asBinding());
+$5=_st($1)._yourself();
+group=$5;
+_st($HLOpenCommand())._registerConcreteClassesOn_(group);
+$6=group;
+return $6;
+}, function($ctx1) {$ctx1.fill(self,"defaultBindings",{group:group},globals.HLKeyBinder)})},
+args: [],
+source: "defaultBindings\x0a\x09| group |\x0a\x09\x0a\x09group := HLBindingGroup new\x0a\x09\x09add: HLCloseTabCommand new asBinding;\x0a\x09\x09add: HLSwitchTabCommand new asBinding;\x0a\x09\x09yourself.\x0a\x09\x09\x0a\x09HLOpenCommand registerConcreteClassesOn: group.\x0a\x09\x09\x09\x09\x0a\x09^ group",
+messageSends: ["add:", "new", "asBinding", "yourself", "registerConcreteClassesOn:"],
+referencedClasses: ["HLBindingGroup", "HLCloseTabCommand", "HLSwitchTabCommand", "HLOpenCommand"]
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "escapeKey",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (27);
+},
+args: [],
+source: "escapeKey\x0a\x09\x22ESC\x22\x0a\x09^ 27",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "flushBindings",
+protocol: 'actions',
+fn: function (){
+var self=this;
+self["@bindings"]=nil;
+return self},
+args: [],
+source: "flushBindings\x0a\x09bindings := nil",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleActiveKeyDown:",
+protocol: 'events',
+fn: function (event){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$6,$5,$4,$1,$7;
+$3=_st(event)._which();
+$ctx1.sendIdx["which"]=1;
+$2=_st($3).__eq(self._escapeKey());
+$ctx1.sendIdx["="]=1;
+$1=_st($2)._or_((function(){
+return smalltalk.withContext(function($ctx2) {
+$6=_st(event)._which();
+$ctx2.sendIdx["which"]=2;
+$5=_st($6).__eq((71));
+$ctx2.sendIdx["="]=2;
+$4=_st($5)._or_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(_st(event)._which()).__eq(self._activationKey());
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+return _st($4)._and_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(event)._ctrlKey();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["or:"]=1;
+if(smalltalk.assert($1)){
+self._deactivate();
+_st(event)._preventDefault();
+return false;
+};
+$7=self._handleBindingFor_(event);
+return $7;
+}, function($ctx1) {$ctx1.fill(self,"handleActiveKeyDown:",{event:event},globals.HLKeyBinder)})},
+args: ["event"],
+source: "handleActiveKeyDown: event\x0a\x0a\x09\x22ESC, ctrl+g ctrl+space deactivate the keyBinder\x22\x0a\x09(event which = self escapeKey or: [\x0a\x09\x09(event which = 71 or: [ event which = self activationKey ]) \x0a\x09\x09\x09and: [ event ctrlKey ] ])\x0a        \x09\x09ifTrue: [ \x0a           \x09\x09\x09self deactivate.\x0a\x09\x09\x09\x09\x09event preventDefault.\x0a\x09\x09\x09\x09\x09^ false ].\x0a            \x0a    \x22Handle the keybinding\x22\x0a    ^ self handleBindingFor: event",
+messageSends: ["ifTrue:", "or:", "=", "which", "escapeKey", "and:", "activationKey", "ctrlKey", "deactivate", "preventDefault", "handleBindingFor:"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleBindingFor:",
+protocol: 'events',
+fn: function (anEvent){
+var self=this;
+var binding;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+binding=_st(self._selectedBinding())._atKey_(_st(anEvent)._which());
+$1=binding;
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+self._applyBinding_(binding);
+_st(anEvent)._preventDefault();
+return false;
+};
+return self}, function($ctx1) {$ctx1.fill(self,"handleBindingFor:",{anEvent:anEvent,binding:binding},globals.HLKeyBinder)})},
+args: ["anEvent"],
+source: "handleBindingFor: anEvent\x0a\x09| binding |\x0a    binding := self selectedBinding atKey: anEvent which.\x0a    \x0a    binding ifNotNil: [ \x0a    \x09self applyBinding: binding.\x0a\x09\x09anEvent preventDefault.\x0a\x09\x09^ false ]",
+messageSends: ["atKey:", "selectedBinding", "which", "ifNotNil:", "applyBinding:", "preventDefault"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleInactiveKeyDown:",
+protocol: 'events',
+fn: function (event){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(_st(event)._which()).__eq(self._activationKey());
+if(smalltalk.assert($1)){
+$2=_st(event)._ctrlKey();
+if(smalltalk.assert($2)){
+self._activate();
+_st(event)._preventDefault();
+return false;
+};
+};
+return self}, function($ctx1) {$ctx1.fill(self,"handleInactiveKeyDown:",{event:event},globals.HLKeyBinder)})},
+args: ["event"],
+source: "handleInactiveKeyDown: event\x0a\x09event which = self activationKey ifTrue: [\x0a    \x09event ctrlKey ifTrue: [\x0a\x09\x09\x09self activate. \x0a            event preventDefault. \x0a            ^ false ] ]",
+messageSends: ["ifTrue:", "=", "which", "activationKey", "ctrlKey", "activate", "preventDefault"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleKeyDown:",
+protocol: 'events',
+fn: function (event){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=self._isActive();
+if(smalltalk.assert($2)){
+$1=self._handleActiveKeyDown_(event);
+} else {
+$1=self._handleInactiveKeyDown_(event);
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"handleKeyDown:",{event:event},globals.HLKeyBinder)})},
+args: ["event"],
+source: "handleKeyDown: event\x0a\x09^ self isActive\x0a    \x09ifTrue: [ self handleActiveKeyDown: event ]\x0a      \x09ifFalse: [ self handleInactiveKeyDown: event ]",
+messageSends: ["ifTrue:ifFalse:", "isActive", "handleActiveKeyDown:", "handleInactiveKeyDown:"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "helper",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@helper"];
+return $1;
+},
+args: [],
+source: "helper\x0a\x09^ helper",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+function $HLKeyBinderHelperWidget(){return globals.HLKeyBinderHelperWidget||(typeof HLKeyBinderHelperWidget=="undefined"?nil:HLKeyBinderHelperWidget)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLKeyBinder.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self["@helper"]=_st($HLKeyBinderHelperWidget())._on_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLKeyBinder)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09helper := HLKeyBinderHelperWidget on: self",
+messageSends: ["initialize", "on:"],
+referencedClasses: ["HLKeyBinderHelperWidget"]
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(".".__comma(_st(self._helper())._cssClass()))._asJQuery())._is_(":visible");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLKeyBinder)})},
+args: [],
+source: "isActive\x0a\x09^ ('.', self helper cssClass) asJQuery is: ':visible'",
+messageSends: ["is:", "asJQuery", ",", "cssClass", "helper"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectBinding:",
+protocol: 'actions',
+fn: function (aBinding){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aBinding).__eq(self["@selectedBinding"]);
+if(smalltalk.assert($1)){
+return self;
+};
+self["@selectedBinding"]=aBinding;
+_st(self._helper())._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"selectBinding:",{aBinding:aBinding},globals.HLKeyBinder)})},
+args: ["aBinding"],
+source: "selectBinding: aBinding\x0a\x09aBinding = selectedBinding ifTrue: [ ^ self ].\x0a\x09\x0a\x09selectedBinding := aBinding.\x0a\x09self helper refresh",
+messageSends: ["ifTrue:", "=", "refresh", "helper"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedBinding",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@selectedBinding"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=self._bindings();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedBinding",{},globals.HLKeyBinder)})},
+args: [],
+source: "selectedBinding\x0a\x09^ selectedBinding ifNil: [ self bindings ]",
+messageSends: ["ifNil:", "bindings"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupEvents",
+protocol: 'events',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st("body"._asJQuery())._keydown_((function(event){
+return smalltalk.withContext(function($ctx2) {
+return self._handleKeyDown_(event);
+}, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupEvents",{},globals.HLKeyBinder)})},
+args: [],
+source: "setupEvents\x0a\x09'body' asJQuery keydown: [ :event | self handleKeyDown: event ]",
+messageSends: ["keydown:", "asJQuery", "handleKeyDown:"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "systemIsMac",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(navigator)._platform())._match_("Mac");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"systemIsMac",{},globals.HLKeyBinder)})},
+args: [],
+source: "systemIsMac\x0a\x09^ navigator platform match: 'Mac'",
+messageSends: ["match:", "platform"],
+referencedClasses: []
+}),
+globals.HLKeyBinder);
+
+
+globals.HLKeyBinder.klass.iVarNames = ['current'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "current",
+protocol: 'instance creation',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@current"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@current"]=($ctx1.supercall = true, globals.HLKeyBinder.klass.superclass.fn.prototype._new.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=self["@current"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"current",{},globals.HLKeyBinder.klass)})},
+args: [],
+source: "current\x0a\x09^ current ifNil: [ current := super new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: []
+}),
+globals.HLKeyBinder.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "new",
+protocol: 'instance creation',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._shouldNotImplement();
+return self}, function($ctx1) {$ctx1.fill(self,"new",{},globals.HLKeyBinder.klass)})},
+args: [],
+source: "new\x0a\x09self shouldNotImplement",
+messageSends: ["shouldNotImplement"],
+referencedClasses: []
+}),
+globals.HLKeyBinder.klass);
+
+
+smalltalk.addClass('HLKeyBinderHelperWidget', globals.HLWidget, ['keyBinder'], 'Helios-KeyBindings');
+globals.HLKeyBinderHelperWidget.comment="I am the widget responsible for displaying active keybindings in a bar at the bottom of the window. Each keybinding is an instance of `HLBinding`. \x0a\x0aRendering is done through a double dispatch, see `#renderSelectedBindingOn:`.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "key_helper";
+},
+args: [],
+source: "cssClass\x0a\x09^ 'key_helper'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "deactivate",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._keyBinder())._deactivate();
+return self}, function($ctx1) {$ctx1.fill(self,"deactivate",{},globals.HLKeyBinderHelperWidget)})},
+args: [],
+source: "deactivate\x0a\x09self keyBinder deactivate",
+messageSends: ["deactivate", "keyBinder"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hide",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(".".__comma(self._cssClass()))._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._remove();
+$ctx1.sendIdx["remove"]=1;
+_st(".helper_overlay"._asJQuery())._remove();
+self._showCog();
+return self}, function($ctx1) {$ctx1.fill(self,"hide",{},globals.HLKeyBinderHelperWidget)})},
+args: [],
+source: "hide\x0a\x09('.', self cssClass) asJQuery remove.\x0a\x09'.helper_overlay' asJQuery remove.\x0a\x09self showCog",
+messageSends: ["remove", "asJQuery", ",", "cssClass", "showCog"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hideCog",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st("#cog-helper"._asJQuery())._hide();
+return self}, function($ctx1) {$ctx1.fill(self,"hideCog",{},globals.HLKeyBinderHelperWidget)})},
+args: [],
+source: "hideCog\x0a\x09'#cog-helper' asJQuery hide",
+messageSends: ["hide", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "keyBinder",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@keyBinder"];
+return $1;
+},
+args: [],
+source: "keyBinder\x0a\x09^ keyBinder",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "keyBinder:",
+protocol: 'accessing',
+fn: function (aKeyBinder){
+var self=this;
+self["@keyBinder"]=aKeyBinder;
+return self},
+args: ["aKeyBinder"],
+source: "keyBinder: aKeyBinder\x0a\x09keyBinder := aKeyBinder",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "mainId",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "binding-helper-main";
+},
+args: [],
+source: "mainId\x0a\x09^ 'binding-helper-main'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderBindingActionFor:on:",
+protocol: 'rendering',
+fn: function (aBinding,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$5,$6,$2;
+$1=_st(html)._span();
+_st($1)._class_("command");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._strong();
+_st($3)._class_("label");
+$ctx2.sendIdx["class:"]=2;
+$4=_st($3)._with_(_st(_st(aBinding)._shortcut())._asLowercase());
+$ctx2.sendIdx["with:"]=2;
+$4;
+$5=_st(html)._a();
+_st($5)._class_("action");
+_st($5)._with_(_st(aBinding)._displayLabel());
+$6=_st($5)._onClick_((function(){
+return smalltalk.withContext(function($ctx3) {
+return _st(self._keyBinder())._applyBinding_(aBinding);
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
+return $6;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderBindingActionFor:on:",{aBinding:aBinding,html:html},globals.HLKeyBinderHelperWidget)})},
+args: ["aBinding", "html"],
+source: "renderBindingActionFor: aBinding on: html\x0a\x09html span class: 'command'; with: [\x0a\x09\x09html strong \x0a\x09\x09\x09class: 'label'; \x0a\x09\x09\x09with: aBinding shortcut asLowercase.\x0a  \x09\x09html a \x0a        \x09class: 'action'; \x0a            with: aBinding displayLabel;\x0a  \x09\x09\x09onClick: [ self keyBinder applyBinding: aBinding ] ]",
+messageSends: ["class:", "span", "with:", "strong", "asLowercase", "shortcut", "a", "displayLabel", "onClick:", "applyBinding:", "keyBinder"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderBindingGroup:on:",
+protocol: 'rendering',
+fn: function (aBindingGroup,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+_st(_st(_st(aBindingGroup)._activeBindings())._sorted_((function(a,b){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(a)._key();
+$ctx2.sendIdx["key"]=1;
+return _st($1).__lt(_st(b)._key());
+}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,1)})})))._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return self._renderBindingActionFor_on_(each,html);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderBindingGroup:on:",{aBindingGroup:aBindingGroup,html:html},globals.HLKeyBinderHelperWidget)})},
+args: ["aBindingGroup", "html"],
+source: "renderBindingGroup: aBindingGroup on: html\x0a\x09(aBindingGroup activeBindings \x0a    \x09sorted: [ :a :b | a key < b key ])\x0a        do: [ :each | self renderBindingActionFor: each on: html ]",
+messageSends: ["do:", "sorted:", "activeBindings", "<", "key", "renderBindingActionFor:on:"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderCloseOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._a();
+_st($1)._class_("close");
+$ctx1.sendIdx["class:"]=1;
+_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(html)._tag_("i"))._class_("icon-remove");
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._keyBinder())._deactivate();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderCloseOn:",{html:html},globals.HLKeyBinderHelperWidget)})},
+args: ["html"],
+source: "renderCloseOn: html\x0a\x09html a\x0a\x09\x09class: 'close';\x0a\x09\x09with: [ (html tag: 'i') class: 'icon-remove' ];\x0a\x09\x09onClick: [ self keyBinder deactivate ]",
+messageSends: ["class:", "a", "with:", "tag:", "onClick:", "deactivate", "keyBinder"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$5,$6,$4;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._id_("overlay");
+$ctx1.sendIdx["id:"]=1;
+_st($1)._class_("helper_overlay");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._deactivate();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$3=_st(html)._div();
+$ctx1.sendIdx["div"]=2;
+_st($3)._class_(self._cssClass());
+$4=_st($3)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+self._renderLabelOn_(html);
+$5=_st(html)._div();
+_st($5)._id_(self._mainId());
+$6=_st($5)._with_((function(){
+return smalltalk.withContext(function($ctx3) {
+return self._renderSelectedBindingOn_(html);
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
+$6;
+return self._renderCloseOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$ctx1.sendIdx["with:"]=1;
+_st(":focus"._asJQuery())._blur();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLKeyBinderHelperWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html div \x0a\x09\x09id: 'overlay';\x0a\x09\x09class: 'helper_overlay';\x0a\x09\x09onClick: [ self deactivate ].\x0a\x09\x0a\x09html div class: self cssClass; with: [\x0a      \x09self renderLabelOn: html.\x0a\x09\x09html div\x0a\x09\x09\x09id: self mainId;\x0a\x09\x09\x09with: [ self renderSelectedBindingOn: html ].\x0a\x09\x09self renderCloseOn: html ].\x0a\x09\x09\x0a\x09':focus' asJQuery blur",
+messageSends: ["id:", "div", "class:", "onClick:", "deactivate", "cssClass", "with:", "renderLabelOn:", "mainId", "renderSelectedBindingOn:", "renderCloseOn:", "blur", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderLabelOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$5,$4,$2,$receiver;
+$1=_st(html)._span();
+_st($1)._class_("selected");
+$3=$1;
+$5=_st(self._selectedBinding())._label();
+if(($receiver = $5) == null || $receiver.isNil){
+$4="Action";
+} else {
+$4=$5;
+};
+$2=_st($3)._with_($4);
+return self}, function($ctx1) {$ctx1.fill(self,"renderLabelOn:",{html:html},globals.HLKeyBinderHelperWidget)})},
+args: ["html"],
+source: "renderLabelOn: html\x0a\x09\x09html span \x0a        \x09class: 'selected'; \x0a            with: (self selectedBinding label ifNil: [ 'Action' ])",
+messageSends: ["class:", "span", "with:", "ifNil:", "label", "selectedBinding"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderSelectedBindingOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._selectedBinding())._renderOn_html_(self,html);
+return self}, function($ctx1) {$ctx1.fill(self,"renderSelectedBindingOn:",{html:html},globals.HLKeyBinderHelperWidget)})},
+args: ["html"],
+source: "renderSelectedBindingOn: html\x0a\x09self selectedBinding renderOn: self html: html",
+messageSends: ["renderOn:html:", "selectedBinding"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectedBinding",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._keyBinder())._selectedBinding();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectedBinding",{},globals.HLKeyBinderHelperWidget)})},
+args: [],
+source: "selectedBinding\x0a\x09^ self keyBinder selectedBinding",
+messageSends: ["selectedBinding", "keyBinder"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._hideCog();
+self._appendToJQuery_("body"._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"show",{},globals.HLKeyBinderHelperWidget)})},
+args: [],
+source: "show\x0a\x09self hideCog.\x0a\x09self appendToJQuery: 'body' asJQuery",
+messageSends: ["hideCog", "appendToJQuery:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showCog",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st("#cog-helper"._asJQuery())._show();
+return self}, function($ctx1) {$ctx1.fill(self,"showCog",{},globals.HLKeyBinderHelperWidget)})},
+args: [],
+source: "showCog\x0a\x09'#cog-helper' asJQuery show",
+messageSends: ["show", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "showWidget:",
+protocol: 'actions',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1;
+$3=self._mainId();
+$ctx1.sendIdx["mainId"]=1;
+$2="#".__comma($3);
+$ctx1.sendIdx[","]=1;
+$1=_st($2)._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._empty();
+_st(aWidget)._appendToJQuery_(_st("#".__comma(self._mainId()))._asJQuery());
+return self}, function($ctx1) {$ctx1.fill(self,"showWidget:",{aWidget:aWidget},globals.HLKeyBinderHelperWidget)})},
+args: ["aWidget"],
+source: "showWidget: aWidget\x0a\x09\x22Some actions need to display more info to the user or request input.\x0a\x09This method is the right place for that\x22\x0a\x09\x0a\x09('#', self mainId) asJQuery empty.\x0a\x09aWidget appendToJQuery: ('#', self mainId) asJQuery",
+messageSends: ["empty", "asJQuery", ",", "mainId", "appendToJQuery:"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aKeyBinder){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._keyBinder_(aKeyBinder);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aKeyBinder:aKeyBinder},globals.HLKeyBinderHelperWidget.klass)})},
+args: ["aKeyBinder"],
+source: "on: aKeyBinder\x0a\x09^ self new\x0a    \x09keyBinder: aKeyBinder;\x0a        yourself",
+messageSends: ["keyBinder:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLKeyBinderHelperWidget.klass);
+
+
+smalltalk.addClass('HLRepeatedKeyDownHandler', globals.Object, ['repeatInterval', 'delay', 'interval', 'keyBindings', 'widget', 'keyDown'], 'Helios-KeyBindings');
+globals.HLRepeatedKeyDownHandler.comment="I am responsible for handling repeated key down actions for widgets.\x0a\x0a##Usage\x0a\x0a    (self on: aWidget)\x0a        whileKeyDown: 38 do: aBlock;\x0a        whileKeyDown: 40 do: anotherBlock;\x0a        bindKeys\x0a\x0aI perform an action block on a key press, wait for 300 ms and then preform the same action block every `repeatInterval` milliseconds until the key is released.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "bindKeys",
+protocol: 'binding',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._widget())._bindKeyDown_keyUp_((function(e){
+return smalltalk.withContext(function($ctx2) {
+return self._handleKeyDown_(e);
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)})}),(function(e){
+return smalltalk.withContext(function($ctx2) {
+return self._handleKeyUp();
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"bindKeys",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "bindKeys\x0a\x09self widget \x0a\x09\x09bindKeyDown: [ :e | self handleKeyDown: e ] \x0a\x09\x09keyUp: [ :e | self handleKeyUp ]",
+messageSends: ["bindKeyDown:keyUp:", "widget", "handleKeyDown:", "handleKeyUp"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultRepeatInterval",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return (70);
+},
+args: [],
+source: "defaultRepeatInterval\x0a\x09^ 70",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleEvent:forKey:action:",
+protocol: 'events handling',
+fn: function (anEvent,anInteger,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(anEvent)._which()).__eq(anInteger))._and_((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._isKeyDown())._not();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+if(smalltalk.assert($1)){
+self._whileKeyDownDo_(aBlock);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"handleEvent:forKey:action:",{anEvent:anEvent,anInteger:anInteger,aBlock:aBlock},globals.HLRepeatedKeyDownHandler)})},
+args: ["anEvent", "anInteger", "aBlock"],
+source: "handleEvent: anEvent forKey: anInteger action: aBlock\x0a\x09(anEvent which = anInteger and: [ self isKeyDown not ])\x0a\x09\x09ifTrue: [ self whileKeyDownDo: aBlock ]",
+messageSends: ["ifTrue:", "and:", "=", "which", "not", "isKeyDown", "whileKeyDownDo:"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleKeyDown:",
+protocol: 'events handling',
+fn: function (anEvent){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._keyBindings())._keysAndValuesDo_((function(key,action){
+return smalltalk.withContext(function($ctx2) {
+return self._handleEvent_forKey_action_(anEvent,key,action);
+}, function($ctx2) {$ctx2.fillBlock({key:key,action:action},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"handleKeyDown:",{anEvent:anEvent},globals.HLRepeatedKeyDownHandler)})},
+args: ["anEvent"],
+source: "handleKeyDown: anEvent\x0a\x09self keyBindings keysAndValuesDo: [ :key :action | \x0a\x09\x09self handleEvent: anEvent forKey: key action: action ]",
+messageSends: ["keysAndValuesDo:", "keyBindings", "handleEvent:forKey:action:"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "handleKeyUp",
+protocol: 'events handling',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$receiver;
+$1=self._isKeyDown();
+if(smalltalk.assert($1)){
+self["@keyDown"]=false;
+self["@keyDown"];
+$2=self["@interval"];
+if(($receiver = $2) == null || $receiver.isNil){
+$2;
+} else {
+_st(self["@interval"])._clearInterval();
+};
+$3=self["@delay"];
+if(($receiver = $3) == null || $receiver.isNil){
+$3;
+} else {
+_st(self["@delay"])._clearTimeout();
+};
+};
+return self}, function($ctx1) {$ctx1.fill(self,"handleKeyUp",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "handleKeyUp\x0a\x09self isKeyDown ifTrue: [\x0a\x09\x09keyDown := false.\x0a\x09\x09interval ifNotNil: [ interval clearInterval ].\x0a\x09\x09delay ifNotNil: [ delay clearTimeout ] ]",
+messageSends: ["ifTrue:", "isKeyDown", "ifNotNil:", "clearInterval", "clearTimeout"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isKeyDown",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@keyDown"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=false;
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isKeyDown",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "isKeyDown\x0a\x09^ keyDown ifNil: [ false ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "keyBindings",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@keyBindings"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@keyBindings"]=_st($Dictionary())._new();
+$1=self["@keyBindings"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"keyBindings",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "keyBindings\x0a\x09^ keyBindings ifNil: [ keyBindings := Dictionary new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["Dictionary"]
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "rebindKeys",
+protocol: 'binding',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._unbindKeys();
+$1=self._bindKeys();
+return self}, function($ctx1) {$ctx1.fill(self,"rebindKeys",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "rebindKeys\x0a\x09self \x0a\x09\x09unbindKeys;\x0a\x09\x09bindKeys",
+messageSends: ["unbindKeys", "bindKeys"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "repeatInterval",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@repeatInterval"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=self._defaultRepeatInterval();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"repeatInterval",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "repeatInterval\x0a\x09^ repeatInterval ifNil: [ self defaultRepeatInterval ]",
+messageSends: ["ifNil:", "defaultRepeatInterval"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "repeatInterval:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+self["@repeatInterval"]=anInteger;
+return self},
+args: ["anInteger"],
+source: "repeatInterval: anInteger\x0a\x09repeatInterval := anInteger",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "startRepeatingAction:",
+protocol: 'actions',
+fn: function (aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$1=_st((function(){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(self._widget())._hasFocus();
+if(smalltalk.assert($2)){
+return _st(aBlock)._value();
+} else {
+return self._handleKeyUp();
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._valueWithInterval_(self._repeatInterval());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"startRepeatingAction:",{aBlock:aBlock},globals.HLRepeatedKeyDownHandler)})},
+args: ["aBlock"],
+source: "startRepeatingAction: aBlock\x0a\x09^ [ (self widget hasFocus)\x0a\x09\x09ifTrue: [ aBlock value ]\x0a\x09\x09ifFalse: [ self handleKeyUp ] ] valueWithInterval: self repeatInterval",
+messageSends: ["valueWithInterval:", "ifTrue:ifFalse:", "hasFocus", "widget", "value", "handleKeyUp", "repeatInterval"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unbindKeys",
+protocol: 'binding',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._widget())._unbindKeyDownKeyUp();
+return self}, function($ctx1) {$ctx1.fill(self,"unbindKeys",{},globals.HLRepeatedKeyDownHandler)})},
+args: [],
+source: "unbindKeys\x0a\x09self widget unbindKeyDownKeyUp",
+messageSends: ["unbindKeyDownKeyUp", "widget"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "whileKeyDown:do:",
+protocol: 'actions',
+fn: function (aKey,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._keyBindings())._at_put_(aKey,aBlock);
+return self}, function($ctx1) {$ctx1.fill(self,"whileKeyDown:do:",{aKey:aKey,aBlock:aBlock},globals.HLRepeatedKeyDownHandler)})},
+args: ["aKey", "aBlock"],
+source: "whileKeyDown: aKey do: aBlock\x0a\x09self keyBindings at: aKey put: aBlock",
+messageSends: ["at:put:", "keyBindings"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "whileKeyDownDo:",
+protocol: 'events handling',
+fn: function (aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@keyDown"]=true;
+_st(aBlock)._value();
+self["@delay"]=_st((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@interval"]=self._startRepeatingAction_(aBlock);
+return self["@interval"];
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._valueWithTimeout_((300));
+return self}, function($ctx1) {$ctx1.fill(self,"whileKeyDownDo:",{aBlock:aBlock},globals.HLRepeatedKeyDownHandler)})},
+args: ["aBlock"],
+source: "whileKeyDownDo: aBlock\x0a\x09keyDown := true.\x0a\x09aBlock value.\x0a\x09delay := [ interval := self startRepeatingAction: aBlock ] \x0a\x09\x09valueWithTimeout: 300",
+messageSends: ["value", "valueWithTimeout:", "startRepeatingAction:"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "widget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@widget"];
+return $1;
+},
+args: [],
+source: "widget\x0a\x09^ widget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "widget:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+self["@widget"]=aWidget;
+return self},
+args: ["aWidget"],
+source: "widget: aWidget\x0a\x09widget := aWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._widget_(aWidget);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aWidget:aWidget},globals.HLRepeatedKeyDownHandler.klass)})},
+args: ["aWidget"],
+source: "on: aWidget\x0a\x09^ self new\x0a\x09\x09widget: aWidget;\x0a\x09\x09yourself",
+messageSends: ["widget:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLRepeatedKeyDownHandler.klass);
+
+});

src/Helios-KeyBindings.st

@@ -0,0 +1,737 @@
+Smalltalk createPackage: 'Helios-KeyBindings'!
+Object subclass: #HLBinding
+	instanceVariableNames: 'key label'
+	package: 'Helios-KeyBindings'!
+!HLBinding commentStamp!
+I am the abstract representation of a keybinding in Helios. My instances hold a key (integer value) and a label. 
+
+Bindings are built into a tree of keys, so pressing a key may result in more key choices (for example, to open a workspace, 'o' is pressed first then 'w' is pressed).
+
+Binding action handling and selection is handled by the `current` instance of `HLKeyBinder`.
+
+Subclasses implement specific behavior like evaluating actions or (sub-)grouping other bindings.!
+
+!HLBinding methodsFor: 'accessing'!
+
+atKey: aKey
+	"Answer the sub-binding at key aKey.
+	Always answer nil here. See HLBindingGroup for more."
+	
+	^ nil
+!
+
+displayLabel
+	^ self label
+!
+
+key
+	^ key
+!
+
+key: anInteger
+	key := anInteger
+!
+
+label
+	^ label
+!
+
+label: aString
+	label := aString
+!
+
+shortcut
+	^ String fromCharCode: self key
+! !
+
+!HLBinding methodsFor: 'actions'!
+
+apply
+!
+
+release
+! !
+
+!HLBinding methodsFor: 'rendering'!
+
+renderOn: aBindingHelper html: html
+! !
+
+!HLBinding methodsFor: 'testing'!
+
+isActive
+	^ self subclassResponsibility
+! !
+
+!HLBinding class methodsFor: 'instance creation'!
+
+on: anInteger labelled: aString
+	^ self new
+    	key: anInteger;
+        label: aString;
+        yourself
+! !
+
+HLBinding subclass: #HLBindingAction
+	instanceVariableNames: 'command'
+	package: 'Helios-KeyBindings'!
+!HLBindingAction commentStamp!
+My instances are the leafs of the binding tree. They evaluate actions through commands, instances of concrete subclasses of `HLCommand`.
+
+The `#apply` methods is used to evaluate the `command`. If the command requires user input, an `inputWidget` will be displayed to the user.!
+
+!HLBindingAction methodsFor: 'accessing'!
+
+command
+	^ command
+!
+
+command: aCommand
+	command := aCommand
+!
+
+input: aString
+	self command input: aString
+!
+
+inputBinding
+	^ HLBindingInput new
+		label: self command inputLabel;
+		ghostText: self command displayLabel;
+		defaultValue: self command defaultInput;
+		inputCompletion: self command inputCompletion;
+		callback: [ :val | 
+			self command 
+				input: val;
+				execute ];
+		yourself
+!
+
+inputWidget
+	^ HLBindingActionInputWidget new
+		ghostText: self command displayLabel;
+		defaultValue: self command defaultInput;
+		inputCompletion: self command inputCompletion;
+		callback: [ :value | 
+			self 
+				input: value;
+				executeCommand ];
+		yourself
+! !
+
+!HLBindingAction methodsFor: 'actions'!
+
+apply
+	self command isInputRequired
+		ifTrue: [ HLKeyBinder current helper showWidget: self inputWidget ]
+		ifFalse: [ self executeCommand ]
+!
+
+executeCommand
+	self command execute.
+	HLKeyBinder current deactivate
+! !
+
+!HLBindingAction methodsFor: 'testing'!
+
+isActive
+	^ self command isActive
+! !
+
+HLBinding subclass: #HLBindingGroup
+	instanceVariableNames: 'bindings'
+	package: 'Helios-KeyBindings'!
+!HLBindingGroup commentStamp!
+My instances hold other bindings, either actions or groups, and do not have actions by themselves.
+
+Children are accessed with `atKey:` and added with the `add*` methods.!
+
+!HLBindingGroup methodsFor: 'accessing'!
+
+activeBindings
+	^ self bindings select: [ :each | each isActive ]
+!
+
+at: aString
+	^ self bindings 
+    	detect: [ :each | each label = aString ]
+      	ifNone: [ nil ]
+!
+
+at: aString add: aBinding
+	| binding |
+	
+	binding := self at: aString.
+	binding ifNil: [ ^ self ].
+		
+	binding add: aBinding
+!
+
+atKey: anInteger
+	^ self bindings 
+    	detect: [ :each | each key = anInteger ]
+      	ifNone: [ nil ]
+!
+
+bindings
+	^ bindings ifNil: [ bindings := OrderedCollection new ]
+!
+
+displayLabel
+	^ super displayLabel, '...'
+! !
+
+!HLBindingGroup methodsFor: 'actions'!
+
+release
+	self bindings do: [ :each | each release ]
+! !
+
+!HLBindingGroup methodsFor: 'add'!
+
+addGroupKey: anInteger labelled: aString
+	self add: (HLBindingGroup on: anInteger labelled: aString)
+! !
+
+!HLBindingGroup methodsFor: 'adding'!
+
+add: aBinding
+	^ self bindings add: aBinding
+!
+
+addActionKey: anInteger labelled: aString callback: aBlock
+	self add: ((HLBindingAction on: anInteger labelled: aString)
+    	callback: aBlock;
+        yourself)
+! !
+
+!HLBindingGroup methodsFor: 'rendering'!
+
+renderOn: aBindingHelper html: html
+	self isActive ifTrue: [
+		aBindingHelper renderBindingGroup: self on: html ]
+! !
+
+!HLBindingGroup methodsFor: 'testing'!
+
+isActive
+	^ self activeBindings notEmpty
+! !
+
+HLWidget subclass: #HLBindingActionInputWidget
+	instanceVariableNames: 'input callback status wrapper ghostText message inputCompletion defaultValue messageTag'
+	package: 'Helios-KeyBindings'!
+!HLBindingActionInputWidget commentStamp!
+My instances are built when a `HLBindingAction` that requires user input is applied.!
+
+!HLBindingActionInputWidget methodsFor: 'accessing'!
+
+callback
+	^ callback ifNil: [ callback := [ :value | ] ]
+!
+
+callback: aBlock
+	callback := aBlock
+!
+
+defaultValue
+	^ defaultValue ifNil: [ '' ]
+!
+
+defaultValue: aString
+	defaultValue := aString
+!
+
+ghostText
+	^ ghostText
+!
+
+ghostText: aText
+	ghostText := aText
+!
+
+input
+	^ input
+!
+
+inputCompletion
+	^ inputCompletion ifNil: [ #() ]
+!
+
+inputCompletion: aCollection
+	inputCompletion := aCollection
+!
+
+message
+	^ message ifNil: [ message := '' ]
+!
+
+message: aString
+	message := aString
+!
+
+status
+	^ status ifNil: [ status := 'info' ]
+!
+
+status: aStatus
+	status := aStatus
+! !
+
+!HLBindingActionInputWidget methodsFor: 'actions'!
+
+clearStatus
+	self status: 'info'.
+	self message: ''.
+	self refresh
+!
+
+errorStatus
+	self status: 'error'.
+	self refresh
+!
+
+evaluate: aString	
+	[ self callback value: aString ]
+		on: Error
+		do: [ :ex |
+			self input asJQuery 
+				one: 'keydown' 
+				do: [ self clearStatus ].
+			self message: ex messageText.
+			self errorStatus ]
+!
+
+refresh
+	wrapper ifNil: [ ^ self ].
+    
+	wrapper class: self status.
+	messageTag contents: self message
+! !
+
+!HLBindingActionInputWidget methodsFor: 'rendering'!
+
+renderOn: html
+	wrapper ifNil: [ wrapper := html span ].
+
+	wrapper 
+		class: self status;
+		with: [
+			input := html input
+				placeholder: self ghostText;
+				value: self defaultValue;
+				onKeyDown: [ :event | 
+					event which = 13 ifTrue: [
+						self evaluate: input asJQuery val ] ]
+				yourself.
+			input asJQuery 
+				typeahead: #{ 'source' -> self inputCompletion }.
+			messageTag := (html span
+				class: 'help-inline';
+				with: self message;
+				yourself) ].
+	
+	"Evaluate with a timeout to ensure focus.
+	Commands can be executed from a menu, clicking on the menu to
+	evaluate the command would give it the focus otherwise"
+	
+	[ input asJQuery focus; select ] valueWithTimeout: 10
+! !
+
+Object subclass: #HLKeyBinder
+	instanceVariableNames: 'modifierKey helper bindings selectedBinding'
+	package: 'Helios-KeyBindings'!
+!HLKeyBinder commentStamp!
+My `current` instance holds keybindings for Helios actions and evaluate them.
+
+Bindings can be nested by groups. The `bindings` instance variable holds the root of the key bindings tree.
+
+Bindings are instances of a concrete subclass of `HLBinding`.
+
+I am always either in 'active' or 'inactive' state. In active state I capture key down events and my `helper` widget is displayed at the bottom of the window. My `selectedBinding`, if any, is displayed by the helper.
+
+Bindings are evaluated through `applyBinding:`. If a binding is final (not a group of other bindings), evaluating it will result in deactivating the binder, and hiding the `helper` widget.!
+
+!HLKeyBinder methodsFor: 'accessing'!
+
+activationKey
+	"SPACE"
+	^ 32
+!
+
+activationKeyLabel
+	^ 'ctrl + space'
+!
+
+bindings
+	^ bindings ifNil: [ bindings := self defaultBindings ]
+!
+
+escapeKey
+	"ESC"
+	^ 27
+!
+
+helper
+	^ helper
+!
+
+selectedBinding
+	^ selectedBinding ifNil: [ self bindings ]
+! !
+
+!HLKeyBinder methodsFor: 'actions'!
+
+activate
+	self helper show
+!
+
+applyBinding: aBinding
+	aBinding isActive ifFalse: [ ^ self ].
+	
+	self selectBinding: aBinding.
+    aBinding apply
+!
+
+deactivate
+	selectedBinding ifNotNil: [ selectedBinding release ].
+    selectedBinding := nil.
+	self helper hide
+!
+
+flushBindings
+	bindings := nil
+!
+
+selectBinding: aBinding
+	aBinding = selectedBinding ifTrue: [ ^ self ].
+	
+	selectedBinding := aBinding.
+	self helper refresh
+! !
+
+!HLKeyBinder methodsFor: 'defaults'!
+
+defaultBindings
+	| group |
+	
+	group := HLBindingGroup new
+		add: HLCloseTabCommand new asBinding;
+		add: HLSwitchTabCommand new asBinding;
+		yourself.
+		
+	HLOpenCommand registerConcreteClassesOn: group.
+				
+	^ group
+! !
+
+!HLKeyBinder methodsFor: 'events'!
+
+handleActiveKeyDown: event
+
+	"ESC, ctrl+g ctrl+space deactivate the keyBinder"
+	(event which = self escapeKey or: [
+		(event which = 71 or: [ event which = self activationKey ]) 
+			and: [ event ctrlKey ] ])
+        		ifTrue: [ 
+           			self deactivate.
+					event preventDefault.
+					^ false ].
+            
+    "Handle the keybinding"
+    ^ self handleBindingFor: event
+!
+
+handleBindingFor: anEvent
+	| binding |
+    binding := self selectedBinding atKey: anEvent which.
+    
+    binding ifNotNil: [ 
+    	self applyBinding: binding.
+		anEvent preventDefault.
+		^ false ]
+!
+
+handleInactiveKeyDown: event
+	event which = self activationKey ifTrue: [
+    	event ctrlKey ifTrue: [
+			self activate. 
+            event preventDefault. 
+            ^ false ] ]
+!
+
+handleKeyDown: event
+	^ self isActive
+    	ifTrue: [ self handleActiveKeyDown: event ]
+      	ifFalse: [ self handleInactiveKeyDown: event ]
+!
+
+setupEvents
+	'body' asJQuery keydown: [ :event | self handleKeyDown: event ]
+! !
+
+!HLKeyBinder methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	helper := HLKeyBinderHelperWidget on: self
+! !
+
+!HLKeyBinder methodsFor: 'testing'!
+
+isActive
+	^ ('.', self helper cssClass) asJQuery is: ':visible'
+!
+
+systemIsMac
+	^ navigator platform match: 'Mac'
+! !
+
+HLKeyBinder class instanceVariableNames: 'current'!
+
+!HLKeyBinder class methodsFor: 'instance creation'!
+
+current
+	^ current ifNil: [ current := super new ]
+!
+
+new
+	self shouldNotImplement
+! !
+
+HLWidget subclass: #HLKeyBinderHelperWidget
+	instanceVariableNames: 'keyBinder'
+	package: 'Helios-KeyBindings'!
+!HLKeyBinderHelperWidget commentStamp!
+I am the widget responsible for displaying active keybindings in a bar at the bottom of the window. Each keybinding is an instance of `HLBinding`. 
+
+Rendering is done through a double dispatch, see `#renderSelectedBindingOn:`.!
+
+!HLKeyBinderHelperWidget methodsFor: 'accessing'!
+
+cssClass
+	^ 'key_helper'
+!
+
+keyBinder
+	^ keyBinder
+!
+
+keyBinder: aKeyBinder
+	keyBinder := aKeyBinder
+!
+
+mainId
+	^ 'binding-helper-main'
+!
+
+selectedBinding
+	^ self keyBinder selectedBinding
+! !
+
+!HLKeyBinderHelperWidget methodsFor: 'actions'!
+
+deactivate
+	self keyBinder deactivate
+!
+
+hide
+	('.', self cssClass) asJQuery remove.
+	'.helper_overlay' asJQuery remove.
+	self showCog
+!
+
+hideCog
+	'#cog-helper' asJQuery hide
+!
+
+show
+	self hideCog.
+	self appendToJQuery: 'body' asJQuery
+!
+
+showCog
+	'#cog-helper' asJQuery show
+!
+
+showWidget: aWidget
+	"Some actions need to display more info to the user or request input.
+	This method is the right place for that"
+	
+	('#', self mainId) asJQuery empty.
+	aWidget appendToJQuery: ('#', self mainId) asJQuery
+! !
+
+!HLKeyBinderHelperWidget methodsFor: 'rendering'!
+
+renderBindingActionFor: aBinding on: html
+	html span class: 'command'; with: [
+		html strong 
+			class: 'label'; 
+			with: aBinding shortcut asLowercase.
+  		html a 
+        	class: 'action'; 
+            with: aBinding displayLabel;
+  			onClick: [ self keyBinder applyBinding: aBinding ] ]
+!
+
+renderBindingGroup: aBindingGroup on: html
+	(aBindingGroup activeBindings 
+    	sorted: [ :a :b | a key < b key ])
+        do: [ :each | self renderBindingActionFor: each on: html ]
+!
+
+renderCloseOn: html
+	html a
+		class: 'close';
+		with: [ (html tag: 'i') class: 'icon-remove' ];
+		onClick: [ self keyBinder deactivate ]
+!
+
+renderContentOn: html
+	html div 
+		id: 'overlay';
+		class: 'helper_overlay';
+		onClick: [ self deactivate ].
+	
+	html div class: self cssClass; with: [
+      	self renderLabelOn: html.
+		html div
+			id: self mainId;
+			with: [ self renderSelectedBindingOn: html ].
+		self renderCloseOn: html ].
+		
+	':focus' asJQuery blur
+!
+
+renderLabelOn: html
+		html span 
+        	class: 'selected'; 
+            with: (self selectedBinding label ifNil: [ 'Action' ])
+!
+
+renderSelectedBindingOn: html
+	self selectedBinding renderOn: self html: html
+! !
+
+!HLKeyBinderHelperWidget class methodsFor: 'instance creation'!
+
+on: aKeyBinder
+	^ self new
+    	keyBinder: aKeyBinder;
+        yourself
+! !
+
+Object subclass: #HLRepeatedKeyDownHandler
+	instanceVariableNames: 'repeatInterval delay interval keyBindings widget keyDown'
+	package: 'Helios-KeyBindings'!
+!HLRepeatedKeyDownHandler commentStamp!
+I am responsible for handling repeated key down actions for widgets.
+
+##Usage
+
+    (self on: aWidget)
+        whileKeyDown: 38 do: aBlock;
+        whileKeyDown: 40 do: anotherBlock;
+        bindKeys
+
+I perform an action block on a key press, wait for 300 ms and then preform the same action block every `repeatInterval` milliseconds until the key is released.!
+
+!HLRepeatedKeyDownHandler methodsFor: 'accessing'!
+
+keyBindings
+	^ keyBindings ifNil: [ keyBindings := Dictionary new ]
+!
+
+repeatInterval
+	^ repeatInterval ifNil: [ self defaultRepeatInterval ]
+!
+
+repeatInterval: anInteger
+	repeatInterval := anInteger
+!
+
+widget
+	^ widget
+!
+
+widget: aWidget
+	widget := aWidget
+! !
+
+!HLRepeatedKeyDownHandler methodsFor: 'actions'!
+
+startRepeatingAction: aBlock
+	^ [ (self widget hasFocus)
+		ifTrue: [ aBlock value ]
+		ifFalse: [ self handleKeyUp ] ] valueWithInterval: self repeatInterval
+!
+
+whileKeyDown: aKey do: aBlock
+	self keyBindings at: aKey put: aBlock
+! !
+
+!HLRepeatedKeyDownHandler methodsFor: 'binding'!
+
+bindKeys
+	self widget 
+		bindKeyDown: [ :e | self handleKeyDown: e ] 
+		keyUp: [ :e | self handleKeyUp ]
+!
+
+rebindKeys
+	self 
+		unbindKeys;
+		bindKeys
+!
+
+unbindKeys
+	self widget unbindKeyDownKeyUp
+! !
+
+!HLRepeatedKeyDownHandler methodsFor: 'defaults'!
+
+defaultRepeatInterval
+	^ 70
+! !
+
+!HLRepeatedKeyDownHandler methodsFor: 'events handling'!
+
+handleEvent: anEvent forKey: anInteger action: aBlock
+	(anEvent which = anInteger and: [ self isKeyDown not ])
+		ifTrue: [ self whileKeyDownDo: aBlock ]
+!
+
+handleKeyDown: anEvent
+	self keyBindings keysAndValuesDo: [ :key :action | 
+		self handleEvent: anEvent forKey: key action: action ]
+!
+
+handleKeyUp
+	self isKeyDown ifTrue: [
+		keyDown := false.
+		interval ifNotNil: [ interval clearInterval ].
+		delay ifNotNil: [ delay clearTimeout ] ]
+!
+
+whileKeyDownDo: aBlock
+	keyDown := true.
+	aBlock value.
+	delay := [ interval := self startRepeatingAction: aBlock ] 
+		valueWithTimeout: 300
+! !
+
+!HLRepeatedKeyDownHandler methodsFor: 'testing'!
+
+isKeyDown
+	^ keyDown ifNil: [ false ]
+! !
+
+!HLRepeatedKeyDownHandler class methodsFor: 'instance creation'!
+
+on: aWidget
+	^ self new
+		widget: aWidget;
+		yourself
+! !
+

src/Helios-Layout.js

@@ -0,0 +1,603 @@
+define("helios/Helios-Layout", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Core", "amber_core/Web", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Layout');
+smalltalk.packages["Helios-Layout"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLContainer', globals.HLWidget, ['splitter'], 'Helios-Layout');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("tool_container");
+$2=_st($1)._with_(self._splitter());
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLContainer)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09html div \x0a    \x09class: 'tool_container'; \x0a        with: self splitter",
+messageSends: ["class:", "div", "with:", "splitter"],
+referencedClasses: []
+}),
+globals.HLContainer);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "splitter",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@splitter"];
+return $1;
+},
+args: [],
+source: "splitter\x0a\x09^ splitter",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLContainer);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "splitter:",
+protocol: 'accessing',
+fn: function (aSplitter){
+var self=this;
+self["@splitter"]=aSplitter;
+return self},
+args: ["aSplitter"],
+source: "splitter: aSplitter\x0a\x09splitter := aSplitter",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLContainer);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "with:",
+protocol: 'instance creation',
+fn: function (aSplitter){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._splitter_(aSplitter);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"with:",{aSplitter:aSplitter},globals.HLContainer.klass)})},
+args: ["aSplitter"],
+source: "with: aSplitter\x0a\x09^ self new \x0a    \x09splitter: aSplitter; \x0a        yourself",
+messageSends: ["splitter:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLContainer.klass);
+
+
+smalltalk.addClass('HLSplitter', globals.Widget, ['firstWidget', 'secondWidget', 'firstPane', 'secondPane', 'splitter'], 'Helios-Layout');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "splitter";
+},
+args: [],
+source: "cssClass\x0a\x09^ 'splitter'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "firstWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@firstWidget"];
+return $1;
+},
+args: [],
+source: "firstWidget\x0a\x09^ firstWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "firstWidget:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+self["@firstWidget"]=aWidget;
+return self},
+args: ["aWidget"],
+source: "firstWidget: aWidget\x0a\x09firstWidget := aWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isHeliosSplitter",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isHeliosSplitter\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "panesCssClass",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return "panes";
+},
+args: [],
+source: "panesCssClass\x0a\x09^ 'panes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$5,$6,$7,$2;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._class_(self._panesCssClass());
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._div();
+$ctx2.sendIdx["div"]=2;
+_st($3)._class_("pane");
+$ctx2.sendIdx["class:"]=2;
+$4=_st($3)._with_(self._firstWidget());
+$ctx2.sendIdx["with:"]=2;
+self["@firstPane"]=$4;
+self["@firstPane"];
+$5=_st(html)._div();
+$ctx2.sendIdx["div"]=3;
+self["@splitter"]=_st($5)._class_(self._cssClass());
+$ctx2.sendIdx["class:"]=3;
+self["@splitter"];
+$6=_st(html)._div();
+_st($6)._class_("pane");
+$7=_st($6)._with_(self._secondWidget());
+self["@secondPane"]=$7;
+return self["@secondPane"];
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+self._setupSplitter();
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLSplitter)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09html div class: self panesCssClass; with: [\x0a\x09\x09firstPane := html div class: 'pane'; with: self firstWidget.\x0a    \x09splitter := html div class: self cssClass.\x0a    \x09secondPane := html div class: 'pane'; with: self secondWidget ].\x0a        \x0a\x09self setupSplitter",
+messageSends: ["class:", "div", "panesCssClass", "with:", "firstWidget", "cssClass", "secondWidget", "setupSplitter"],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "resize",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "resize",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "secondWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@secondWidget"];
+return $1;
+},
+args: [],
+source: "secondWidget\x0a\x09^ secondWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "secondWidget:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+self["@secondWidget"]=aWidget;
+return self},
+args: ["aWidget"],
+source: "secondWidget: aWidget\x0a\x09secondWidget := aWidget",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupSplitter",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "setupSplitter",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSplitter);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "with:with:",
+protocol: 'instance creation',
+fn: function (aWidget,anotherWidget){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._firstWidget_(aWidget);
+_st($2)._secondWidget_(anotherWidget);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"with:with:",{aWidget:aWidget,anotherWidget:anotherWidget},globals.HLSplitter.klass)})},
+args: ["aWidget", "anotherWidget"],
+source: "with: aWidget with: anotherWidget\x0a\x09^ self new\x0a    \x09\x09firstWidget: aWidget;\x0a            secondWidget: anotherWidget;\x0a            yourself",
+messageSends: ["firstWidget:", "new", "secondWidget:", "yourself"],
+referencedClasses: []
+}),
+globals.HLSplitter.klass);
+
+
+smalltalk.addClass('HLHorizontalSplitter', globals.HLSplitter, [], 'Helios-Layout');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=($ctx1.supercall = true, globals.HLHorizontalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st($2).__comma(" horizontal");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLHorizontalSplitter)})},
+args: [],
+source: "cssClass\x0a\x09^ super cssClass, ' horizontal'",
+messageSends: [",", "cssClass"],
+referencedClasses: []
+}),
+globals.HLHorizontalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "panesCssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=($ctx1.supercall = true, globals.HLHorizontalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st($2).__comma(" horizontal");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},globals.HLHorizontalSplitter)})},
+args: [],
+source: "panesCssClass\x0a\x09^ super panesCssClass, ' horizontal'",
+messageSends: [",", "panesCssClass"],
+referencedClasses: []
+}),
+globals.HLHorizontalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "resize",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._resize_(_st(_st(self["@splitter"])._asJQuery())._css_("top"));
+return self}, function($ctx1) {$ctx1.fill(self,"resize",{},globals.HLHorizontalSplitter)})},
+args: [],
+source: "resize\x0a\x09self resize: (splitter asJQuery css: 'top')",
+messageSends: ["resize:", "css:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLHorizontalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "resize:",
+protocol: 'actions',
+fn: function (anInteger){
+var self=this;
+var container,size,offset,percentage;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$6,$7,$5,$4,$8,$10,$9,$11,$14,$13,$12;
+$1=_st(self["@firstPane"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+container=_st($1)._parent();
+$3=_st(self["@firstPane"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=2;
+$2=_st($3)._offset();
+offset=_st($2)._top();
+size=_st(container)._height();
+$6=size;
+$7=_st(anInteger).__minus(offset);
+$ctx1.sendIdx["-"]=2;
+$5=_st($6).__minus($7);
+$ctx1.sendIdx["-"]=1;
+$4=_st($5).__slash(size);
+percentage=_st($4).__star((100));
+percentage=(80)._min_(_st(percentage)._max_((20)));
+$8=_st(self["@firstPane"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=3;
+$10=_st(percentage)._asString();
+$ctx1.sendIdx["asString"]=1;
+$9=_st($10).__comma("%");
+$ctx1.sendIdx[","]=1;
+_st($8)._css_put_("bottom",$9);
+$ctx1.sendIdx["css:put:"]=1;
+$11=_st(self["@splitter"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=4;
+$14=(100).__minus(percentage);
+$ctx1.sendIdx["-"]=3;
+$13=_st($14)._asString();
+$ctx1.sendIdx["asString"]=2;
+$12=_st($13).__comma("%");
+$ctx1.sendIdx[","]=2;
+_st($11)._css_put_("top",$12);
+$ctx1.sendIdx["css:put:"]=2;
+_st(_st(self["@secondPane"])._asJQuery())._css_put_("top",_st(_st((100).__minus(percentage))._asString()).__comma("%"));
+return self}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},globals.HLHorizontalSplitter)})},
+args: ["anInteger"],
+source: "resize: anInteger\x0a\x09| container size offset percentage |\x0a    \x0a    container := firstPane asJQuery parent.\x0a\x09offset := firstPane asJQuery offset top.\x0a    size := container height.\x0a\x09\x0a\x09percentage := (size - (anInteger - offset)) / size * 100.\x0a\x09percentage := 80 min: (percentage max: 20).\x0a\x09\x0a    firstPane asJQuery css: 'bottom' put: percentage asString, '%'.\x0a\x09\x0a\x09splitter asJQuery css: 'top' put: (100 - percentage) asString, '%'.\x0a\x09secondPane asJQuery css: 'top' put: (100 - percentage) asString, '%'",
+messageSends: ["parent", "asJQuery", "top", "offset", "height", "*", "/", "-", "min:", "max:", "css:put:", ",", "asString"],
+referencedClasses: []
+}),
+globals.HLHorizontalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupSplitter",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@splitter"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._draggable_(globals.HashedCollection._newFromPairs_(["axis","y","containment",_st(_st(self["@splitter"])._asJQuery())._parent(),"helper","clone","start",(function(e,ui){
+return smalltalk.withContext(function($ctx2) {
+return self._startResizing_(_st(ui)._helper());
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,1)})}),"drag",(function(e,ui){
+return smalltalk.withContext(function($ctx2) {
+return self._resize_(_st(_st(ui)._offset())._top());
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)})})]));
+return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},globals.HLHorizontalSplitter)})},
+args: [],
+source: "setupSplitter\x0a\x09splitter asJQuery draggable: #{ \x0a    \x09'axis' -> 'y'. \x0a        'containment' -> splitter asJQuery parent.\x0a        'helper' -> 'clone'.\x0a        'start' -> [ :e :ui | self startResizing: ui helper ].\x0a        'drag' -> [ :e :ui | self resize: ui offset top ] }",
+messageSends: ["draggable:", "asJQuery", "parent", "startResizing:", "helper", "resize:", "top", "offset"],
+referencedClasses: []
+}),
+globals.HLHorizontalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "startResizing:",
+protocol: 'actions',
+fn: function (aSplitter){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(aSplitter)._width_(_st(_st(self["@splitter"])._asJQuery())._width());
+return self}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},globals.HLHorizontalSplitter)})},
+args: ["aSplitter"],
+source: "startResizing: aSplitter\x0a\x09aSplitter width: splitter asJQuery width",
+messageSends: ["width:", "width", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLHorizontalSplitter);
+
+
+
+smalltalk.addClass('HLVerticalSplitter', globals.HLSplitter, [], 'Helios-Layout');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=($ctx1.supercall = true, globals.HLVerticalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st($2).__comma(" vertical");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLVerticalSplitter)})},
+args: [],
+source: "cssClass\x0a\x09^ super cssClass, ' vertical'",
+messageSends: [",", "cssClass"],
+referencedClasses: []
+}),
+globals.HLVerticalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "panesCssClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=($ctx1.supercall = true, globals.HLVerticalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), []));
+$ctx1.supercall = false;
+$1=_st($2).__comma(" vertical");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},globals.HLVerticalSplitter)})},
+args: [],
+source: "panesCssClass\x0a\x09^ super panesCssClass, ' vertical'",
+messageSends: [",", "panesCssClass"],
+referencedClasses: []
+}),
+globals.HLVerticalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "resize",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._resize_(_st(_st(self["@splitter"])._asJQuery())._css_("left"));
+return self}, function($ctx1) {$ctx1.fill(self,"resize",{},globals.HLVerticalSplitter)})},
+args: [],
+source: "resize\x0a\x09self resize: (splitter asJQuery css: 'left')",
+messageSends: ["resize:", "css:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLVerticalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "resize:",
+protocol: 'actions',
+fn: function (anInteger){
+var self=this;
+var container,size,offset,percentage;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$6,$7,$5,$4,$8,$10,$9,$11,$14,$13,$12;
+$1=_st(self["@firstPane"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+container=_st($1)._parent();
+$3=_st(self["@firstPane"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=2;
+$2=_st($3)._offset();
+offset=_st($2)._left();
+size=_st(container)._width();
+$6=size;
+$7=_st(anInteger).__minus(offset);
+$ctx1.sendIdx["-"]=2;
+$5=_st($6).__minus($7);
+$ctx1.sendIdx["-"]=1;
+$4=_st($5).__slash(size);
+percentage=_st($4).__star((100));
+percentage=(80)._min_(_st(percentage)._max_((20)));
+$8=_st(self["@firstPane"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=3;
+$10=_st(percentage)._asString();
+$ctx1.sendIdx["asString"]=1;
+$9=_st($10).__comma("%");
+$ctx1.sendIdx[","]=1;
+_st($8)._css_put_("right",$9);
+$ctx1.sendIdx["css:put:"]=1;
+$11=_st(self["@splitter"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=4;
+$14=(100).__minus(percentage);
+$ctx1.sendIdx["-"]=3;
+$13=_st($14)._asString();
+$ctx1.sendIdx["asString"]=2;
+$12=_st($13).__comma("%");
+$ctx1.sendIdx[","]=2;
+_st($11)._css_put_("left",$12);
+$ctx1.sendIdx["css:put:"]=2;
+_st(_st(self["@secondPane"])._asJQuery())._css_put_("left",_st(_st((100).__minus(percentage))._asString()).__comma("%"));
+return self}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},globals.HLVerticalSplitter)})},
+args: ["anInteger"],
+source: "resize: anInteger\x0a\x09| container size offset percentage |\x0a    \x0a    container := firstPane asJQuery parent.\x0a\x09offset := firstPane asJQuery offset left.\x0a    size := container width.\x0a\x09\x0a\x09percentage := (size - (anInteger - offset)) / size * 100.\x0a\x09percentage := 80 min: (percentage max: 20).\x0a\x09\x0a    firstPane asJQuery css: 'right' put: percentage asString, '%'.\x0a\x09\x0a\x09splitter asJQuery css: 'left' put: (100 - percentage) asString, '%'.\x0a\x09secondPane asJQuery css: 'left' put: (100 - percentage) asString, '%'",
+messageSends: ["parent", "asJQuery", "left", "offset", "width", "*", "/", "-", "min:", "max:", "css:put:", ",", "asString"],
+referencedClasses: []
+}),
+globals.HLVerticalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupSplitter",
+protocol: 'rendering',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@splitter"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($1)._draggable_(globals.HashedCollection._newFromPairs_(["axis","x","containment",_st(_st(self["@splitter"])._asJQuery())._parent(),"helper","clone","start",(function(e,ui){
+return smalltalk.withContext(function($ctx2) {
+return self._startResizing_(_st(ui)._helper());
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,1)})}),"drag",(function(e,ui){
+return smalltalk.withContext(function($ctx2) {
+return self._resize_(_st(_st(ui)._offset())._left());
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)})})]));
+return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},globals.HLVerticalSplitter)})},
+args: [],
+source: "setupSplitter\x0a\x09splitter asJQuery draggable: #{ \x0a    \x09'axis' -> 'x'. \x0a        'containment' -> splitter asJQuery parent.\x0a        'helper' -> 'clone'.\x0a        'start' -> [ :e :ui | self startResizing: ui helper ].\x0a        'drag' -> [ :e :ui | self resize: (ui offset left) ] }",
+messageSends: ["draggable:", "asJQuery", "parent", "startResizing:", "helper", "resize:", "left", "offset"],
+referencedClasses: []
+}),
+globals.HLVerticalSplitter);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "startResizing:",
+protocol: 'actions',
+fn: function (aSplitter){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(aSplitter)._height_(_st(_st(self["@splitter"])._asJQuery())._height());
+return self}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},globals.HLVerticalSplitter)})},
+args: ["aSplitter"],
+source: "startResizing: aSplitter\x0a\x09aSplitter height: splitter asJQuery height",
+messageSends: ["height:", "height", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLVerticalSplitter);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isHeliosSplitter",
+protocol: '*Helios-Layout',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "isHeliosSplitter\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.Object);
+
+});

src/Helios-Layout.st

@@ -0,0 +1,201 @@
+Smalltalk createPackage: 'Helios-Layout'!
+HLWidget subclass: #HLContainer
+	instanceVariableNames: 'splitter'
+	package: 'Helios-Layout'!
+
+!HLContainer methodsFor: 'accessing'!
+
+splitter
+	^ splitter
+!
+
+splitter: aSplitter
+	splitter := aSplitter
+! !
+
+!HLContainer methodsFor: 'rendering'!
+
+renderOn: html
+	html div 
+    	class: 'tool_container'; 
+        with: self splitter
+! !
+
+!HLContainer class methodsFor: 'instance creation'!
+
+with: aSplitter
+	^ self new 
+    	splitter: aSplitter; 
+        yourself
+! !
+
+Widget subclass: #HLSplitter
+	instanceVariableNames: 'firstWidget secondWidget firstPane secondPane splitter'
+	package: 'Helios-Layout'!
+
+!HLSplitter methodsFor: 'accessing'!
+
+cssClass
+	^ 'splitter'
+!
+
+firstWidget
+	^ firstWidget
+!
+
+firstWidget: aWidget
+	firstWidget := aWidget
+!
+
+secondWidget
+	^ secondWidget
+!
+
+secondWidget: aWidget
+	secondWidget := aWidget
+! !
+
+!HLSplitter methodsFor: 'rendering'!
+
+panesCssClass
+	^ 'panes'
+!
+
+renderOn: html
+	html div class: self panesCssClass; with: [
+		firstPane := html div class: 'pane'; with: self firstWidget.
+    	splitter := html div class: self cssClass.
+    	secondPane := html div class: 'pane'; with: self secondWidget ].
+        
+	self setupSplitter
+!
+
+resize
+!
+
+setupSplitter
+! !
+
+!HLSplitter methodsFor: 'testing'!
+
+isHeliosSplitter
+	^ true
+! !
+
+!HLSplitter class methodsFor: 'instance creation'!
+
+with: aWidget with: anotherWidget
+	^ self new
+    		firstWidget: aWidget;
+            secondWidget: anotherWidget;
+            yourself
+! !
+
+HLSplitter subclass: #HLHorizontalSplitter
+	instanceVariableNames: ''
+	package: 'Helios-Layout'!
+
+!HLHorizontalSplitter methodsFor: 'accessing'!
+
+cssClass
+	^ super cssClass, ' horizontal'
+!
+
+panesCssClass
+	^ super panesCssClass, ' horizontal'
+! !
+
+!HLHorizontalSplitter methodsFor: 'actions'!
+
+resize
+	self resize: (splitter asJQuery css: 'top')
+!
+
+resize: anInteger
+	| container size offset percentage |
+    
+    container := firstPane asJQuery parent.
+	offset := firstPane asJQuery offset top.
+    size := container height.
+	
+	percentage := (size - (anInteger - offset)) / size * 100.
+	percentage := 80 min: (percentage max: 20).
+	
+    firstPane asJQuery css: 'bottom' put: percentage asString, '%'.
+	
+	splitter asJQuery css: 'top' put: (100 - percentage) asString, '%'.
+	secondPane asJQuery css: 'top' put: (100 - percentage) asString, '%'
+!
+
+startResizing: aSplitter
+	aSplitter width: splitter asJQuery width
+! !
+
+!HLHorizontalSplitter methodsFor: 'rendering'!
+
+setupSplitter
+	splitter asJQuery draggable: #{ 
+    	'axis' -> 'y'. 
+        'containment' -> splitter asJQuery parent.
+        'helper' -> 'clone'.
+        'start' -> [ :e :ui | self startResizing: ui helper ].
+        'drag' -> [ :e :ui | self resize: ui offset top ] }
+! !
+
+HLSplitter subclass: #HLVerticalSplitter
+	instanceVariableNames: ''
+	package: 'Helios-Layout'!
+
+!HLVerticalSplitter methodsFor: 'accessing'!
+
+cssClass
+	^ super cssClass, ' vertical'
+!
+
+panesCssClass
+	^ super panesCssClass, ' vertical'
+! !
+
+!HLVerticalSplitter methodsFor: 'actions'!
+
+resize
+	self resize: (splitter asJQuery css: 'left')
+!
+
+resize: anInteger
+	| container size offset percentage |
+    
+    container := firstPane asJQuery parent.
+	offset := firstPane asJQuery offset left.
+    size := container width.
+	
+	percentage := (size - (anInteger - offset)) / size * 100.
+	percentage := 80 min: (percentage max: 20).
+	
+    firstPane asJQuery css: 'right' put: percentage asString, '%'.
+	
+	splitter asJQuery css: 'left' put: (100 - percentage) asString, '%'.
+	secondPane asJQuery css: 'left' put: (100 - percentage) asString, '%'
+!
+
+startResizing: aSplitter
+	aSplitter height: splitter asJQuery height
+! !
+
+!HLVerticalSplitter methodsFor: 'rendering'!
+
+setupSplitter
+	splitter asJQuery draggable: #{ 
+    	'axis' -> 'x'. 
+        'containment' -> splitter asJQuery parent.
+        'helper' -> 'clone'.
+        'start' -> [ :e :ui | self startResizing: ui helper ].
+        'drag' -> [ :e :ui | self resize: (ui offset left) ] }
+! !
+
+!Object methodsFor: '*Helios-Layout'!
+
+isHeliosSplitter
+	^ false
+! !
+

src/Helios-References.js

@@ -0,0 +1,1138 @@
+define("helios/Helios-References", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "helios/Helios-Core"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-References');
+smalltalk.packages["Helios-References"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLMethodReference', globals.Object, ['selector', 'methodClass'], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initializeFromMethod:",
+protocol: 'initialization',
+fn: function (aCompiledMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._selector_(_st(aCompiledMethod)._selector());
+$1=self._methodClass_(_st(aCompiledMethod)._methodClass());
+return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethod:",{aCompiledMethod:aCompiledMethod},globals.HLMethodReference)})},
+args: ["aCompiledMethod"],
+source: "initializeFromMethod: aCompiledMethod\x0a\x09self\x0a\x09\x09selector: aCompiledMethod selector;\x0a\x09\x09methodClass: aCompiledMethod methodClass",
+messageSends: ["selector:", "selector", "methodClass:", "methodClass"],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "method",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._methodClass())._methodAt_(self._selector());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"method",{},globals.HLMethodReference)})},
+args: [],
+source: "method\x0a\x09^ self methodClass methodAt: self selector",
+messageSends: ["methodAt:", "methodClass", "selector"],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@methodClass"];
+return $1;
+},
+args: [],
+source: "methodClass\x0a\x09^ methodClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodClass:",
+protocol: 'accessing',
+fn: function (aClass){
+var self=this;
+self["@methodClass"]=aClass;
+return self},
+args: ["aClass"],
+source: "methodClass: aClass\x0a\x09methodClass := aClass",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selector",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@selector"];
+return $1;
+},
+args: [],
+source: "selector\x0a\x09^ selector",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selector:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+self["@selector"]=aString;
+return self},
+args: ["aString"],
+source: "selector: aString\x0a\x09selector := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "source",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._method())._source();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"source",{},globals.HLMethodReference)})},
+args: [],
+source: "source\x0a\x09^ self method source",
+messageSends: ["source", "method"],
+referencedClasses: []
+}),
+globals.HLMethodReference);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aCompiledMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._initializeFromMethod_(aCompiledMethod);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aCompiledMethod:aCompiledMethod},globals.HLMethodReference.klass)})},
+args: ["aCompiledMethod"],
+source: "on: aCompiledMethod\x0a\x09^ self new\x0a\x09\x09initializeFromMethod: aCompiledMethod;\x0a\x09\x09yourself",
+messageSends: ["initializeFromMethod:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLMethodReference.klass);
+
+
+smalltalk.addClass('HLReferences', globals.HLWidget, ['model', 'sendersListWidget', 'implementorsListWidget', 'classReferencesListWidget', 'regexpListWidget', 'sourceCodeWidget'], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classReferencesListWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLClassReferencesListWidget(){return globals.HLClassReferencesListWidget||(typeof HLClassReferencesListWidget=="undefined"?nil:HLClassReferencesListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@classReferencesListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@classReferencesListWidget"]=_st($HLClassReferencesListWidget())._on_(self._model());
+self["@classReferencesListWidget"];
+$1=_st(self["@classReferencesListWidget"])._next_(self._regexpListWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"classReferencesListWidget",{},globals.HLReferences)})},
+args: [],
+source: "classReferencesListWidget\x0a\x09^ classReferencesListWidget ifNil: [\x0a      \x09classReferencesListWidget := HLClassReferencesListWidget on: self model.\x0a\x09\x09classReferencesListWidget next: self regexpListWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "regexpListWidget"],
+referencedClasses: ["HLClassReferencesListWidget"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "implementorsListWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLImplementorsListWidget(){return globals.HLImplementorsListWidget||(typeof HLImplementorsListWidget=="undefined"?nil:HLImplementorsListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@implementorsListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@implementorsListWidget"]=_st($HLImplementorsListWidget())._on_(self._model());
+self["@implementorsListWidget"];
+$1=_st(self["@implementorsListWidget"])._next_(self._classReferencesListWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"implementorsListWidget",{},globals.HLReferences)})},
+args: [],
+source: "implementorsListWidget\x0a\x09^ implementorsListWidget ifNil: [\x0a      \x09implementorsListWidget := HLImplementorsListWidget on: self model.\x0a\x09\x09implementorsListWidget next: self classReferencesListWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "classReferencesListWidget"],
+referencedClasses: ["HLImplementorsListWidget"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLReferencesModel(){return globals.HLReferencesModel||(typeof HLReferencesModel=="undefined"?nil:HLReferencesModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@model"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLReferencesModel())._new();
+_st($3)._environment_(_st(self._manager())._environment());
+$4=_st($3)._yourself();
+self["@model"]=$4;
+$1=self["@model"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLReferences)})},
+args: [],
+source: "model\x0a\x09^ model ifNil: [\x0a\x09\x09model := (HLReferencesModel new\x0a\x09\x09\x09environment: self manager environment;\x0a\x09\x09\x09yourself) ]",
+messageSends: ["ifNil:", "environment:", "new", "environment", "manager", "yourself"],
+referencedClasses: ["HLReferencesModel"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+self["@model"]=aModel;
+return self},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "regexpListWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLRegexpListWidget(){return globals.HLRegexpListWidget||(typeof HLRegexpListWidget=="undefined"?nil:HLRegexpListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@regexpListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@regexpListWidget"]=_st($HLRegexpListWidget())._on_(self._model());
+self["@regexpListWidget"];
+$1=_st(self["@regexpListWidget"])._next_(self._sourceCodeWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"regexpListWidget",{},globals.HLReferences)})},
+args: [],
+source: "regexpListWidget\x0a\x09^ regexpListWidget ifNil: [\x0a      \x09regexpListWidget := HLRegexpListWidget on: self model.\x0a\x09\x09regexpListWidget next: self sourceCodeWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "sourceCodeWidget"],
+referencedClasses: ["HLRegexpListWidget"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "registerBindingsOn:",
+protocol: 'actions',
+fn: function (aBindingGroup){
+var self=this;
+function $HLToolCommand(){return globals.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLToolCommand())._registerConcreteClassesOn_for_(aBindingGroup,self._model());
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},globals.HLReferences)})},
+args: ["aBindingGroup"],
+source: "registerBindingsOn: aBindingGroup\x0a\x09HLToolCommand \x0a\x09\x09registerConcreteClassesOn: aBindingGroup \x0a\x09\x09for: self model",
+messageSends: ["registerConcreteClassesOn:for:", "model"],
+referencedClasses: ["HLToolCommand"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+var $5,$4,$3,$2,$1;
+$5=self._sendersListWidget();
+$ctx1.sendIdx["sendersListWidget"]=1;
+$4=_st($HLVerticalSplitter())._with_with_($5,self._implementorsListWidget());
+$ctx1.sendIdx["with:with:"]=3;
+$3=_st($HLVerticalSplitter())._with_with_($4,_st($HLVerticalSplitter())._with_with_(self._classReferencesListWidget(),self._regexpListWidget()));
+$ctx1.sendIdx["with:with:"]=2;
+$2=_st($HLHorizontalSplitter())._with_with_($3,self._sourceCodeWidget());
+$ctx1.sendIdx["with:with:"]=1;
+$1=_st($HLContainer())._with_($2);
+_st(html)._with_($1);
+$ctx1.sendIdx["with:"]=1;
+_st(self._sendersListWidget())._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLReferences)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html with: (HLContainer with: (HLHorizontalSplitter \x0a    \x09with: (HLVerticalSplitter\x0a        \x09with: (HLVerticalSplitter\x0a            \x09with: self sendersListWidget\x0a                with: self implementorsListWidget)\x0a            with: (HLVerticalSplitter\x0a            \x09with: self classReferencesListWidget\x0a                with: self regexpListWidget)) \x0a        with: self sourceCodeWidget)).\x0a\x09\x0a\x09self sendersListWidget focus",
+messageSends: ["with:", "with:with:", "sendersListWidget", "implementorsListWidget", "classReferencesListWidget", "regexpListWidget", "sourceCodeWidget", "focus"],
+referencedClasses: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "search:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._search_(aString);
+self._setTabLabel_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"search:",{aString:aString},globals.HLReferences)})},
+args: ["aString"],
+source: "search: aString\x0a\x09self model search: aString.\x0a\x09self setTabLabel: aString",
+messageSends: ["search:", "model", "setTabLabel:"],
+referencedClasses: []
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sendersListWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLSendersListWidget(){return globals.HLSendersListWidget||(typeof HLSendersListWidget=="undefined"?nil:HLSendersListWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@sendersListWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@sendersListWidget"]=_st($HLSendersListWidget())._on_(self._model());
+self["@sendersListWidget"];
+$1=_st(self["@sendersListWidget"])._next_(self._implementorsListWidget());
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"sendersListWidget",{},globals.HLReferences)})},
+args: [],
+source: "sendersListWidget\x0a\x09^ sendersListWidget ifNil: [\x0a      \x09sendersListWidget := HLSendersListWidget on: self model.\x0a\x09\x09sendersListWidget next: self implementorsListWidget ]",
+messageSends: ["ifNil:", "on:", "model", "next:", "implementorsListWidget"],
+referencedClasses: ["HLSendersListWidget"]
+}),
+globals.HLReferences);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sourceCodeWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLBrowserCodeWidget(){return globals.HLBrowserCodeWidget||(typeof HLBrowserCodeWidget=="undefined"?nil:HLBrowserCodeWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$4,$1,$receiver;
+$2=self["@sourceCodeWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+$3=_st($HLBrowserCodeWidget())._new();
+_st($3)._browserModel_(self._model());
+$4=_st($3)._yourself();
+self["@sourceCodeWidget"]=$4;
+$1=self["@sourceCodeWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"sourceCodeWidget",{},globals.HLReferences)})},
+args: [],
+source: "sourceCodeWidget\x0a\x09^ sourceCodeWidget ifNil: [\x0a      \x09sourceCodeWidget := HLBrowserCodeWidget new\x0a\x09\x09\x09browserModel: self model;\x0a\x09\x09\x09yourself ]",
+messageSends: ["ifNil:", "browserModel:", "new", "model", "yourself"],
+referencedClasses: ["HLBrowserCodeWidget"]
+}),
+globals.HLReferences);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferences.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "references";
+},
+args: [],
+source: "tabClass\x0a\x09^ 'references'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferences.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "References";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'References'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferences.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabPriority",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (100);
+},
+args: [],
+source: "tabPriority\x0a\x09^ 100",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferences.klass);
+
+
+smalltalk.addClass('HLReferencesListWidget', globals.HLToolListWidget, [], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "activateListItem:",
+protocol: 'actions',
+fn: function (anItem){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+return ($ctx2.supercall = true, globals.HLReferencesListWidget.superclass.fn.prototype._activateListItem_.apply(_st(self), [anItem]));
+$ctx2.supercall = false;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"activateListItem:",{anItem:anItem},globals.HLReferencesListWidget)})},
+args: ["anItem"],
+source: "activateListItem: anItem\x0a\x09self model withChangesDo: [ super activateListItem: anItem ]",
+messageSends: ["withChangesDo:", "model", "activateListItem:"],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "commandCategory",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Methods";
+},
+args: [],
+source: "commandCategory\x0a\x09^ 'Methods'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "List";
+},
+args: [],
+source: "label\x0a\x09^ 'List'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLSearchReferences(){return globals.HLSearchReferences||(typeof HLSearchReferences=="undefined"?nil:HLSearchReferences)}
+function $HLMethodSelected(){return globals.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._model())._announcer();
+_st($1)._on_do_($HLSearchReferences(),(function(ann){
+return smalltalk.withContext(function($ctx2) {
+return self._onSearchReferences_(_st(ann)._searchString());
+}, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,1)})}));
+$ctx1.sendIdx["on:do:"]=1;
+$2=_st($1)._on_do_($HLMethodSelected(),(function(ann){
+return smalltalk.withContext(function($ctx2) {
+return self._onMethodSelected_(_st(ann)._item());
+}, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLReferencesListWidget)})},
+args: [],
+source: "observeModel\x0a\x09self model announcer\x0a\x09\x09on: HLSearchReferences\x0a\x09\x09do: [ :ann | self onSearchReferences: ann searchString ];\x0a\x09\x09on: HLMethodSelected\x0a\x09\x09do: [ :ann | self onMethodSelected: ann item ]",
+messageSends: ["on:do:", "announcer", "model", "onSearchReferences:", "searchString", "onMethodSelected:", "item"],
+referencedClasses: ["HLSearchReferences", "HLMethodSelected"]
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodSelected:",
+protocol: 'reactions',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$receiver;
+var $early={};
+try {
+if(($receiver = aMethod) == null || $receiver.isNil){
+return self;
+} else {
+aMethod;
+};
+_st(self._items())._detect_ifNone_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$1=_st(aMethod)._selector();
+$ctx2.sendIdx["selector"]=1;
+return _st(each).__eq($1);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}),(function(){
+throw $early=[self];
+}));
+$2=_st(aMethod)._selector();
+$ctx1.sendIdx["selector"]=2;
+self._selectedItem_($2);
+$3=self._activateItem_(_st(aMethod)._selector());
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{aMethod:aMethod},globals.HLReferencesListWidget)})},
+args: ["aMethod"],
+source: "onMethodSelected: aMethod\x0a\x09aMethod ifNil: [ ^ self ].\x0a\x09self items detect: [ :each | each = aMethod selector ] ifNone: [ ^ self ].\x0a\x09\x0a\x09self \x0a\x09\x09selectedItem: aMethod selector;\x0a\x09\x09activateItem: aMethod selector",
+messageSends: ["ifNil:", "detect:ifNone:", "items", "=", "selector", "selectedItem:", "activateItem:"],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSearchReferences:",
+protocol: 'reactions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._subclassResponsibility();
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLReferencesListWidget)})},
+args: ["aString"],
+source: "onSearchReferences: aString\x0a\x09self subclassResponsibility",
+messageSends: ["subclassResponsibility"],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderItemLabel:on:",
+protocol: 'rendering',
+fn: function (aMethod,html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(_st(_st(aMethod)._methodClass())._name()).__comma(" >> #")).__comma(_st(aMethod)._selector());
+$ctx1.sendIdx[","]=1;
+_st(html)._with_($1);
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aMethod:aMethod,html:html},globals.HLReferencesListWidget)})},
+args: ["aMethod", "html"],
+source: "renderItemLabel: aMethod on: html\x0a\x09html with: aMethod methodClass name, ' >> #', aMethod selector",
+messageSends: ["with:", ",", "name", "methodClass", "selector"],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectItem:",
+protocol: 'actions',
+fn: function (aMethod){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._selectedMethod_(aMethod);
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aMethod:aMethod},globals.HLReferencesListWidget)})},
+args: ["aMethod"],
+source: "selectItem: aMethod\x0a\x09self model selectedMethod: aMethod",
+messageSends: ["selectedMethod:", "model"],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._model_(aModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aModel:aModel},globals.HLReferencesListWidget.klass)})},
+args: ["aModel"],
+source: "on: aModel\x0a\x09^ self new \x0a\x09\x09model: aModel; \x0a\x09\x09yourself",
+messageSends: ["model:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLReferencesListWidget.klass);
+
+
+smalltalk.addClass('HLClassReferencesListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Class references";
+},
+args: [],
+source: "label\x0a\x09^ 'Class references'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLClassReferencesListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSearchReferences:",
+protocol: 'reactions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectItem_(nil);
+self._items_(_st(self._model())._classReferencesOf_(aString));
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLClassReferencesListWidget)})},
+args: ["aString"],
+source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model classReferencesOf: aString).\x0a\x09self refresh",
+messageSends: ["selectItem:", "items:", "classReferencesOf:", "model", "refresh"],
+referencedClasses: []
+}),
+globals.HLClassReferencesListWidget);
+
+
+
+smalltalk.addClass('HLImplementorsListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Implementors";
+},
+args: [],
+source: "label\x0a\x09^ 'Implementors'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLImplementorsListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSearchReferences:",
+protocol: 'reactions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectItem_(nil);
+self._items_(_st(self._model())._implementorsOf_(aString));
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLImplementorsListWidget)})},
+args: ["aString"],
+source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model implementorsOf: aString).\x0a\x09self refresh",
+messageSends: ["selectItem:", "items:", "implementorsOf:", "model", "refresh"],
+referencedClasses: []
+}),
+globals.HLImplementorsListWidget);
+
+
+
+smalltalk.addClass('HLRegexpListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Source search";
+},
+args: [],
+source: "label\x0a\x09^ 'Source search'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLRegexpListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSearchReferences:",
+protocol: 'reactions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectItem_(nil);
+self._items_(_st(self._model())._regexpReferencesOf_(aString));
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLRegexpListWidget)})},
+args: ["aString"],
+source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model regexpReferencesOf: aString).\x0a\x09self refresh",
+messageSends: ["selectItem:", "items:", "regexpReferencesOf:", "model", "refresh"],
+referencedClasses: []
+}),
+globals.HLRegexpListWidget);
+
+
+
+smalltalk.addClass('HLSendersListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Senders";
+},
+args: [],
+source: "label\x0a\x09^ 'Senders'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSendersListWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSearchReferences:",
+protocol: 'reactions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._selectItem_(nil);
+self._items_(_st(self._model())._sendersOf_(aString));
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLSendersListWidget)})},
+args: ["aString"],
+source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model sendersOf: aString).\x0a\x09self refresh",
+messageSends: ["selectItem:", "items:", "sendersOf:", "model", "refresh"],
+referencedClasses: []
+}),
+globals.HLSendersListWidget);
+
+
+
+smalltalk.addClass('HLReferencesModel', globals.HLToolModel, ['methodsCache', 'classesAndMetaclassesCache'], 'Helios-References');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "allMethods",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._methodsCache();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"allMethods",{},globals.HLReferencesModel)})},
+args: [],
+source: "allMethods\x0a\x09^ self methodsCache",
+messageSends: ["methodsCache"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classReferencesOf:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._allMethods())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._referencedClasses())._includes_(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"classReferencesOf:",{aString:aString},globals.HLReferencesModel)})},
+args: ["aString"],
+source: "classReferencesOf: aString\x0a\x09\x22Answer all methods referencing the class named aString\x22\x0a\x09\x0a\x09^self allMethods select: [ :each |\x0a\x09\x09\x09(each referencedClasses includes: aString) ].",
+messageSends: ["select:", "allMethods", "includes:", "referencedClasses"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classesAndMetaclasses",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=self._classesAndMetaclassesCache();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"classesAndMetaclasses",{},globals.HLReferencesModel)})},
+args: [],
+source: "classesAndMetaclasses\x0a\x09^ self classesAndMetaclassesCache",
+messageSends: ["classesAndMetaclassesCache"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "classesAndMetaclassesCache",
+protocol: 'cache',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+$1=self["@classesAndMetaclassesCache"];
+if(($receiver = $1) == null || $receiver.isNil){
+self._updateClassesAndMetaclassesCache();
+} else {
+$1;
+};
+$2=self["@classesAndMetaclassesCache"];
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"classesAndMetaclassesCache",{},globals.HLReferencesModel)})},
+args: [],
+source: "classesAndMetaclassesCache\x0a\x09classesAndMetaclassesCache ifNil: [ self updateClassesAndMetaclassesCache ].\x0a\x09^ classesAndMetaclassesCache",
+messageSends: ["ifNil:", "updateClassesAndMetaclassesCache"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "implementorsOf:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._allMethods())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._selector()).__eq(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return self._methodReferenceOn_(each);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"implementorsOf:",{aString:aString},globals.HLReferencesModel)})},
+args: ["aString"],
+source: "implementorsOf: aString\x0a\x09^ (self allMethods select: [ :each |\x0a\x09\x09each selector = aString ])\x0a\x09\x09\x09collect: [ :each | self methodReferenceOn: each ]",
+messageSends: ["collect:", "select:", "allMethods", "=", "selector", "methodReferenceOn:"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isReferencesModel",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isReferencesModel\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodReferenceOn:",
+protocol: 'accessing',
+fn: function (aCompiledMethod){
+var self=this;
+function $HLMethodReference(){return globals.HLMethodReference||(typeof HLMethodReference=="undefined"?nil:HLMethodReference)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st($HLMethodReference())._on_(aCompiledMethod);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"methodReferenceOn:",{aCompiledMethod:aCompiledMethod},globals.HLReferencesModel)})},
+args: ["aCompiledMethod"],
+source: "methodReferenceOn: aCompiledMethod\x0a\x09^ HLMethodReference on: aCompiledMethod",
+messageSends: ["on:"],
+referencedClasses: ["HLMethodReference"]
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodsCache",
+protocol: 'cache',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+$1=self["@methodsCache"];
+if(($receiver = $1) == null || $receiver.isNil){
+self._updateMethodsCache();
+} else {
+$1;
+};
+$2=self["@methodsCache"];
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"methodsCache",{},globals.HLReferencesModel)})},
+args: [],
+source: "methodsCache\x0a\x09methodsCache ifNil: [ self updateMethodsCache ].\x0a\x09^ methodsCache",
+messageSends: ["ifNil:", "updateMethodsCache"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openClassNamed:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+var browser;
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+return smalltalk.withContext(function($ctx1) { 
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+browser=_st($HLBrowser())._openAsTab();
+browser;
+return _st(browser)._openClassNamed_(aString);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"openClassNamed:",{aString:aString,browser:browser},globals.HLReferencesModel)})},
+args: ["aString"],
+source: "openClassNamed: aString\x0a\x09| browser |\x0a\x09\x0a\x09self withChangesDo: [\x0a\x09\x09browser := HLBrowser openAsTab.\x0a\x09\x09browser openClassNamed: aString ]",
+messageSends: ["withChangesDo:", "openAsTab", "openClassNamed:"],
+referencedClasses: ["HLBrowser"]
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "openMethod",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var browser;
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self._selectedMethod();
+$ctx1.sendIdx["selectedMethod"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+return self;
+} else {
+$1;
+};
+self._withChangesDo_((function(){
+return smalltalk.withContext(function($ctx2) {
+browser=_st($HLBrowser())._openAsTab();
+browser;
+return _st(browser)._openMethod_(self._selectedMethod());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"openMethod",{browser:browser},globals.HLReferencesModel)})},
+args: [],
+source: "openMethod\x0a\x09| browser |\x0a\x09\x0a\x09self selectedMethod ifNil: [ ^ self ].\x0a\x09\x0a\x09self withChangesDo: [\x0a\x09\x09browser := HLBrowser openAsTab.\x0a\x09\x09browser openMethod: self selectedMethod ]",
+messageSends: ["ifNil:", "selectedMethod", "withChangesDo:", "openAsTab", "openMethod:"],
+referencedClasses: ["HLBrowser"]
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "regexpReferencesOf:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._allMethods())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._source())._match_(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return self._methodReferenceOn_(each);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"regexpReferencesOf:",{aString:aString},globals.HLReferencesModel)})},
+args: ["aString"],
+source: "regexpReferencesOf: aString\x0a\x09^ (self allMethods select: [ :each |\x0a\x09\x09each source match: aString ])\x0a\x09\x09\x09collect: [ :each | self methodReferenceOn: each ]",
+messageSends: ["collect:", "select:", "allMethods", "match:", "source", "methodReferenceOn:"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "search:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $HLSearchReferences(){return globals.HLSearchReferences||(typeof HLSearchReferences=="undefined"?nil:HLSearchReferences)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+self._updateCaches();
+$1=_st($HLSearchReferences())._new();
+_st($1)._searchString_(aString);
+$2=_st($1)._yourself();
+_st(self._announcer())._announce_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"search:",{aString:aString},globals.HLReferencesModel)})},
+args: ["aString"],
+source: "search: aString\x0a\x09self updateCaches.\x0a\x09\x0a\x09self announcer announce: (HLSearchReferences new\x0a\x09\x09searchString: aString;\x0a\x09\x09yourself)",
+messageSends: ["updateCaches", "announce:", "announcer", "searchString:", "new", "yourself"],
+referencedClasses: ["HLSearchReferences"]
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "sendersOf:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._allMethods())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._messageSends())._includes_(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return self._methodReferenceOn_(each);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"sendersOf:",{aString:aString},globals.HLReferencesModel)})},
+args: ["aString"],
+source: "sendersOf: aString\x0a\x09^ (self allMethods select: [ :each |\x0a\x09\x09each messageSends includes: aString ])\x0a\x09\x09\x09collect: [ :each | self methodReferenceOn: each ]",
+messageSends: ["collect:", "select:", "allMethods", "includes:", "messageSends", "methodReferenceOn:"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateCaches",
+protocol: 'cache',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self._updateClassesAndMetaclassesCache();
+$1=self._updateMethodsCache();
+return self}, function($ctx1) {$ctx1.fill(self,"updateCaches",{},globals.HLReferencesModel)})},
+args: [],
+source: "updateCaches\x0a\x09self \x0a\x09\x09updateClassesAndMetaclassesCache;\x0a\x09\x09updateMethodsCache",
+messageSends: ["updateClassesAndMetaclassesCache", "updateMethodsCache"],
+referencedClasses: []
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateClassesAndMetaclassesCache",
+protocol: 'cache',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+self["@classesAndMetaclassesCache"]=_st($OrderedCollection())._new();
+_st(_st(self._environment())._classes())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$1=self["@classesAndMetaclassesCache"];
+_st($1)._add_(each);
+$ctx2.sendIdx["add:"]=1;
+$2=_st($1)._add_(_st(each)._class());
+return $2;
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"updateClassesAndMetaclassesCache",{},globals.HLReferencesModel)})},
+args: [],
+source: "updateClassesAndMetaclassesCache\x0a\x09classesAndMetaclassesCache := OrderedCollection new.\x0a\x09\x0a\x09self environment classes do: [ :each |\x0a\x09\x09classesAndMetaclassesCache\x0a\x09\x09\x09\x09add: each; \x0a\x09\x09\x09\x09add: each class ]",
+messageSends: ["new", "do:", "classes", "environment", "add:", "class"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLReferencesModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateMethodsCache",
+protocol: 'cache',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+self["@methodsCache"]=_st($OrderedCollection())._new();
+_st(self._classesAndMetaclasses())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(self["@methodsCache"])._addAll_(_st(each)._methods());
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"updateMethodsCache",{},globals.HLReferencesModel)})},
+args: [],
+source: "updateMethodsCache\x0a\x09methodsCache := OrderedCollection new.\x0a\x09\x0a\x09self classesAndMetaclasses\x0a\x09\x09do: [ :each | methodsCache addAll: each methods ]",
+messageSends: ["new", "do:", "classesAndMetaclasses", "addAll:", "methods"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLReferencesModel);
+
+
+});

src/Helios-References.st

@@ -0,0 +1,388 @@
+Smalltalk createPackage: 'Helios-References'!
+Object subclass: #HLMethodReference
+	instanceVariableNames: 'selector methodClass'
+	package: 'Helios-References'!
+
+!HLMethodReference methodsFor: 'accessing'!
+
+method
+	^ self methodClass methodAt: self selector
+!
+
+methodClass
+	^ methodClass
+!
+
+methodClass: aClass
+	methodClass := aClass
+!
+
+selector
+	^ selector
+!
+
+selector: aString
+	selector := aString
+!
+
+source
+	^ self method source
+! !
+
+!HLMethodReference methodsFor: 'initialization'!
+
+initializeFromMethod: aCompiledMethod
+	self
+		selector: aCompiledMethod selector;
+		methodClass: aCompiledMethod methodClass
+! !
+
+!HLMethodReference class methodsFor: 'instance creation'!
+
+on: aCompiledMethod
+	^ self new
+		initializeFromMethod: aCompiledMethod;
+		yourself
+! !
+
+HLWidget subclass: #HLReferences
+	instanceVariableNames: 'model sendersListWidget implementorsListWidget classReferencesListWidget regexpListWidget sourceCodeWidget'
+	package: 'Helios-References'!
+
+!HLReferences methodsFor: 'accessing'!
+
+classReferencesListWidget
+	^ classReferencesListWidget ifNil: [
+      	classReferencesListWidget := HLClassReferencesListWidget on: self model.
+		classReferencesListWidget next: self regexpListWidget ]
+!
+
+implementorsListWidget
+	^ implementorsListWidget ifNil: [
+      	implementorsListWidget := HLImplementorsListWidget on: self model.
+		implementorsListWidget next: self classReferencesListWidget ]
+!
+
+model
+	^ model ifNil: [
+		model := (HLReferencesModel new
+			environment: self manager environment;
+			yourself) ]
+!
+
+model: aModel
+	model := aModel
+!
+
+regexpListWidget
+	^ regexpListWidget ifNil: [
+      	regexpListWidget := HLRegexpListWidget on: self model.
+		regexpListWidget next: self sourceCodeWidget ]
+!
+
+sendersListWidget
+	^ sendersListWidget ifNil: [
+      	sendersListWidget := HLSendersListWidget on: self model.
+		sendersListWidget next: self implementorsListWidget ]
+!
+
+sourceCodeWidget
+	^ sourceCodeWidget ifNil: [
+      	sourceCodeWidget := HLBrowserCodeWidget new
+			browserModel: self model;
+			yourself ]
+! !
+
+!HLReferences methodsFor: 'actions'!
+
+registerBindingsOn: aBindingGroup
+	HLToolCommand 
+		registerConcreteClassesOn: aBindingGroup 
+		for: self model
+!
+
+search: aString
+	self model search: aString.
+	self setTabLabel: aString
+! !
+
+!HLReferences methodsFor: 'rendering'!
+
+renderContentOn: html
+	html with: (HLContainer with: (HLHorizontalSplitter 
+    	with: (HLVerticalSplitter
+        	with: (HLVerticalSplitter
+            	with: self sendersListWidget
+                with: self implementorsListWidget)
+            with: (HLVerticalSplitter
+            	with: self classReferencesListWidget
+                with: self regexpListWidget)) 
+        with: self sourceCodeWidget)).
+	
+	self sendersListWidget focus
+! !
+
+!HLReferences class methodsFor: 'accessing'!
+
+tabClass
+	^ 'references'
+!
+
+tabLabel
+	^ 'References'
+!
+
+tabPriority
+	^ 100
+! !
+
+!HLReferences class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ false
+! !
+
+HLToolListWidget subclass: #HLReferencesListWidget
+	instanceVariableNames: ''
+	package: 'Helios-References'!
+
+!HLReferencesListWidget methodsFor: 'accessing'!
+
+commandCategory
+	^ 'Methods'
+!
+
+label
+	^ 'List'
+! !
+
+!HLReferencesListWidget methodsFor: 'actions'!
+
+activateListItem: anItem
+	self model withChangesDo: [ super activateListItem: anItem ]
+!
+
+observeModel
+	self model announcer
+		on: HLSearchReferences
+		do: [ :ann | self onSearchReferences: ann searchString ];
+		on: HLMethodSelected
+		do: [ :ann | self onMethodSelected: ann item ]
+!
+
+selectItem: aMethod
+	self model selectedMethod: aMethod
+! !
+
+!HLReferencesListWidget methodsFor: 'reactions'!
+
+onMethodSelected: aMethod
+	aMethod ifNil: [ ^ self ].
+	self items detect: [ :each | each = aMethod selector ] ifNone: [ ^ self ].
+	
+	self 
+		selectedItem: aMethod selector;
+		activateItem: aMethod selector
+!
+
+onSearchReferences: aString
+	self subclassResponsibility
+! !
+
+!HLReferencesListWidget methodsFor: 'rendering'!
+
+renderItemLabel: aMethod on: html
+	html with: aMethod methodClass name, ' >> #', aMethod selector
+! !
+
+!HLReferencesListWidget class methodsFor: 'instance creation'!
+
+on: aModel
+	^ self new 
+		model: aModel; 
+		yourself
+! !
+
+HLReferencesListWidget subclass: #HLClassReferencesListWidget
+	instanceVariableNames: ''
+	package: 'Helios-References'!
+
+!HLClassReferencesListWidget methodsFor: 'accessing'!
+
+label
+	^ 'Class references'
+! !
+
+!HLClassReferencesListWidget methodsFor: 'reactions'!
+
+onSearchReferences: aString
+	self selectItem: nil.
+	self items: (self model classReferencesOf: aString).
+	self refresh
+! !
+
+HLReferencesListWidget subclass: #HLImplementorsListWidget
+	instanceVariableNames: ''
+	package: 'Helios-References'!
+
+!HLImplementorsListWidget methodsFor: 'accessing'!
+
+label
+	^ 'Implementors'
+! !
+
+!HLImplementorsListWidget methodsFor: 'reactions'!
+
+onSearchReferences: aString
+	self selectItem: nil.
+	self items: (self model implementorsOf: aString).
+	self refresh
+! !
+
+HLReferencesListWidget subclass: #HLRegexpListWidget
+	instanceVariableNames: ''
+	package: 'Helios-References'!
+
+!HLRegexpListWidget methodsFor: 'accessing'!
+
+label
+	^ 'Source search'
+! !
+
+!HLRegexpListWidget methodsFor: 'reactions'!
+
+onSearchReferences: aString
+	self selectItem: nil.
+	self items: (self model regexpReferencesOf: aString).
+	self refresh
+! !
+
+HLReferencesListWidget subclass: #HLSendersListWidget
+	instanceVariableNames: ''
+	package: 'Helios-References'!
+
+!HLSendersListWidget methodsFor: 'accessing'!
+
+label
+	^ 'Senders'
+! !
+
+!HLSendersListWidget methodsFor: 'reactions'!
+
+onSearchReferences: aString
+	self selectItem: nil.
+	self items: (self model sendersOf: aString).
+	self refresh
+! !
+
+HLToolModel subclass: #HLReferencesModel
+	instanceVariableNames: 'methodsCache classesAndMetaclassesCache'
+	package: 'Helios-References'!
+
+!HLReferencesModel methodsFor: 'accessing'!
+
+allMethods
+	^ self methodsCache
+!
+
+classReferencesOf: aString
+	"Answer all methods referencing the class named aString"
+	
+	^self allMethods select: [ :each |
+			(each referencedClasses includes: aString) ].
+!
+
+classesAndMetaclasses
+	^ self classesAndMetaclassesCache
+!
+
+implementorsOf: aString
+	^ (self allMethods select: [ :each |
+		each selector = aString ])
+			collect: [ :each | self methodReferenceOn: each ]
+!
+
+methodReferenceOn: aCompiledMethod
+	^ HLMethodReference on: aCompiledMethod
+!
+
+regexpReferencesOf: aString
+	^ (self allMethods select: [ :each |
+		each source match: aString ])
+			collect: [ :each | self methodReferenceOn: each ]
+!
+
+sendersOf: aString
+	^ (self allMethods select: [ :each |
+		each messageSends includes: aString ])
+			collect: [ :each | self methodReferenceOn: each ]
+! !
+
+!HLReferencesModel methodsFor: 'actions'!
+
+openClassNamed: aString
+	| browser |
+	
+	self withChangesDo: [
+		browser := HLBrowser openAsTab.
+		browser openClassNamed: aString ]
+!
+
+openMethod
+	| browser |
+	
+	self selectedMethod ifNil: [ ^ self ].
+	
+	self withChangesDo: [
+		browser := HLBrowser openAsTab.
+		browser openMethod: self selectedMethod ]
+!
+
+search: aString
+	self updateCaches.
+	
+	self announcer announce: (HLSearchReferences new
+		searchString: aString;
+		yourself)
+! !
+
+!HLReferencesModel methodsFor: 'cache'!
+
+classesAndMetaclassesCache
+	classesAndMetaclassesCache ifNil: [ self updateClassesAndMetaclassesCache ].
+	^ classesAndMetaclassesCache
+!
+
+methodsCache
+	methodsCache ifNil: [ self updateMethodsCache ].
+	^ methodsCache
+!
+
+updateCaches
+	self 
+		updateClassesAndMetaclassesCache;
+		updateMethodsCache
+!
+
+updateClassesAndMetaclassesCache
+	classesAndMetaclassesCache := OrderedCollection new.
+	
+	self environment classes do: [ :each |
+		classesAndMetaclassesCache
+				add: each; 
+				add: each class ]
+!
+
+updateMethodsCache
+	methodsCache := OrderedCollection new.
+	
+	self classesAndMetaclasses
+		do: [ :each | methodsCache addAll: each methods ]
+! !
+
+!HLReferencesModel methodsFor: 'testing'!
+
+isReferencesModel
+	^ true
+! !
+

src/Helios-SUnit.js

@@ -0,0 +1,67 @@
+define("helios/Helios-SUnit", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Core"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-SUnit');
+smalltalk.packages["Helios-SUnit"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLSUnit', globals.HLWidget, [], 'Helios-SUnit');
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnit.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "sunit";
+},
+args: [],
+source: "tabClass\x0a\x09^ 'sunit'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnit.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "SUnit";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'SUnit'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnit.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabPriority",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (1000);
+},
+args: [],
+source: "tabPriority\x0a\x09^ 1000",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnit.klass);
+
+});

src/Helios-SUnit.st

@@ -0,0 +1,25 @@
+Smalltalk createPackage: 'Helios-SUnit'!
+HLWidget subclass: #HLSUnit
+	instanceVariableNames: ''
+	package: 'Helios-SUnit'!
+
+!HLSUnit class methodsFor: 'accessing'!
+
+tabClass
+	^ 'sunit'
+!
+
+tabLabel
+	^ 'SUnit'
+!
+
+tabPriority
+	^ 1000
+! !
+
+!HLSUnit class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ true
+! !
+

src/Helios-Transcript.js

@@ -0,0 +1,242 @@
+define("helios/Helios-Transcript", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Core", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Transcript');
+smalltalk.packages["Helios-Transcript"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLTranscript', globals.HLWidget, ['textarea'], 'Helios-Transcript');
+globals.HLTranscript.comment="I am a widget responsible for displaying transcript contents.\x0a\x0a## Transcript API\x0a\x0a    Transcript \x0a        show: 'hello world';\x0a        cr;\x0a        show: anObject.\x0a\x0a    Transcript clear.\x0a\x0aSee the `Transcript` service class.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "clear",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self["@textarea"])._asJQuery())._text_("");
+return self}, function($ctx1) {$ctx1.fill(self,"clear",{},globals.HLTranscript)})},
+args: [],
+source: "clear\x0a\x09textarea asJQuery text: ''",
+messageSends: ["text:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLTranscript);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLTranscript.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._register();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLTranscript)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09self register",
+messageSends: ["initialize", "register"],
+referencedClasses: []
+}),
+globals.HLTranscript);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "register",
+protocol: 'registration',
+fn: function (){
+var self=this;
+function $HLTranscriptHandler(){return globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+return smalltalk.withContext(function($ctx1) { 
+_st($HLTranscriptHandler())._register_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"register",{},globals.HLTranscript)})},
+args: [],
+source: "register\x0a\x09HLTranscriptHandler register: self",
+messageSends: ["register:"],
+referencedClasses: ["HLTranscriptHandler"]
+}),
+globals.HLTranscript);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._div();
+_st($1)._class_("transcript");
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@textarea"]=_st(html)._textarea();
+return self["@textarea"];
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLTranscript)})},
+args: ["html"],
+source: "renderOn: html\x0a\x09html div\x0a\x09\x09class: 'transcript';\x0a\x09\x09with: [ textarea := html textarea ]",
+messageSends: ["class:", "div", "with:", "textarea"],
+referencedClasses: []
+}),
+globals.HLTranscript);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+$1=self["@textarea"];
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+_st(_st(self["@textarea"])._asJQuery())._append_(_st(aString)._asString());
+};
+return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},globals.HLTranscript)})},
+args: ["aString"],
+source: "show: aString\x0a\x09textarea ifNotNil: [\x0a \x09\x09textarea asJQuery append: aString asString ]",
+messageSends: ["ifNotNil:", "append:", "asJQuery", "asString"],
+referencedClasses: []
+}),
+globals.HLTranscript);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'registration',
+fn: function (){
+var self=this;
+function $HLTranscriptHandler(){return globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLTranscript.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+_st($HLTranscriptHandler())._unregister_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLTranscript)})},
+args: [],
+source: "unregister\x0a\x09super unregister.\x0a\x09HLTranscriptHandler unregister: self",
+messageSends: ["unregister", "unregister:"],
+referencedClasses: ["HLTranscriptHandler"]
+}),
+globals.HLTranscript);
+
+
+
+smalltalk.addClass('HLTranscriptHandler', globals.Object, [], 'Helios-Transcript');
+globals.HLTranscriptHandler.comment="I handle transcript events, dispatching them to all instances of `HLTranscript`.\x0a\x0a## API\x0a\x0aUse the class-side method `#register:` to add transcript instances.";
+
+globals.HLTranscriptHandler.klass.iVarNames = ['transcripts'];
+smalltalk.addMethod(
+smalltalk.method({
+selector: "clear",
+protocol: 'printing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._transcripts())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._clear();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"clear",{},globals.HLTranscriptHandler.klass)})},
+args: [],
+source: "clear\x0a\x09self transcripts do: [ :each |\x0a\x09\x09each clear ]",
+messageSends: ["do:", "transcripts", "clear"],
+referencedClasses: []
+}),
+globals.HLTranscriptHandler.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "cr",
+protocol: 'printing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._transcripts())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._cr();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"cr",{},globals.HLTranscriptHandler.klass)})},
+args: [],
+source: "cr\x0a\x09self transcripts do: [ :each | each cr ]",
+messageSends: ["do:", "transcripts", "cr"],
+referencedClasses: []
+}),
+globals.HLTranscriptHandler.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "register:",
+protocol: 'registration',
+fn: function (aTranscript){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._transcripts())._add_(aTranscript);
+return self}, function($ctx1) {$ctx1.fill(self,"register:",{aTranscript:aTranscript},globals.HLTranscriptHandler.klass)})},
+args: ["aTranscript"],
+source: "register: aTranscript\x0a\x09self transcripts add: aTranscript",
+messageSends: ["add:", "transcripts"],
+referencedClasses: []
+}),
+globals.HLTranscriptHandler.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "show:",
+protocol: 'printing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._transcripts())._do_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._show_(aString);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},globals.HLTranscriptHandler.klass)})},
+args: ["aString"],
+source: "show: aString\x0a\x09self transcripts do: [ :each |\x0a\x09\x09each show: aString ]",
+messageSends: ["do:", "transcripts", "show:"],
+referencedClasses: []
+}),
+globals.HLTranscriptHandler.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "transcripts",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@transcripts"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@transcripts"]=_st($OrderedCollection())._new();
+$1=self["@transcripts"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"transcripts",{},globals.HLTranscriptHandler.klass)})},
+args: [],
+source: "transcripts\x0a\x09^ transcripts ifNil: [ transcripts := OrderedCollection new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["OrderedCollection"]
+}),
+globals.HLTranscriptHandler.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister:",
+protocol: 'registration',
+fn: function (aTranscript){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._transcripts())._remove_(aTranscript);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister:",{aTranscript:aTranscript},globals.HLTranscriptHandler.klass)})},
+args: ["aTranscript"],
+source: "unregister: aTranscript\x0a\x09self transcripts remove: aTranscript",
+messageSends: ["remove:", "transcripts"],
+referencedClasses: []
+}),
+globals.HLTranscriptHandler.klass);
+
+});

src/Helios-Transcript.st

@@ -0,0 +1,99 @@
+Smalltalk createPackage: 'Helios-Transcript'!
+HLWidget subclass: #HLTranscript
+	instanceVariableNames: 'textarea'
+	package: 'Helios-Transcript'!
+!HLTranscript commentStamp!
+I am a widget responsible for displaying transcript contents.
+
+## Transcript API
+
+    Transcript 
+        show: 'hello world';
+        cr;
+        show: anObject.
+
+    Transcript clear.
+
+See the `Transcript` service class.!
+
+!HLTranscript methodsFor: 'actions'!
+
+clear
+	textarea asJQuery text: ''
+!
+
+show: aString
+	textarea ifNotNil: [
+ 		textarea asJQuery append: aString asString ]
+! !
+
+!HLTranscript methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	self register
+! !
+
+!HLTranscript methodsFor: 'registration'!
+
+register
+	HLTranscriptHandler register: self
+!
+
+unregister
+	super unregister.
+	HLTranscriptHandler unregister: self
+! !
+
+!HLTranscript methodsFor: 'rendering'!
+
+renderOn: html
+	html div
+		class: 'transcript';
+		with: [ textarea := html textarea ]
+! !
+
+Object subclass: #HLTranscriptHandler
+	instanceVariableNames: ''
+	package: 'Helios-Transcript'!
+!HLTranscriptHandler commentStamp!
+I handle transcript events, dispatching them to all instances of `HLTranscript`.
+
+## API
+
+Use the class-side method `#register:` to add transcript instances.!
+
+HLTranscriptHandler class instanceVariableNames: 'transcripts'!
+
+!HLTranscriptHandler class methodsFor: 'accessing'!
+
+transcripts
+	^ transcripts ifNil: [ transcripts := OrderedCollection new ]
+! !
+
+!HLTranscriptHandler class methodsFor: 'printing'!
+
+clear
+	self transcripts do: [ :each |
+		each clear ]
+!
+
+cr
+	self transcripts do: [ :each | each cr ]
+!
+
+show: aString
+	self transcripts do: [ :each |
+		each show: aString ]
+! !
+
+!HLTranscriptHandler class methodsFor: 'registration'!
+
+register: aTranscript
+	self transcripts add: aTranscript
+!
+
+unregister: aTranscript
+	self transcripts remove: aTranscript
+! !
+

src/Helios-Workspace-Tests.js

@@ -0,0 +1,30 @@
+define("helios/Helios-Workspace-Tests", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/SUnit"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Workspace-Tests');
+smalltalk.packages["Helios-Workspace-Tests"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLCodeWidgetTest', globals.TestCase, [], 'Helios-Workspace-Tests');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testKeyMap",
+protocol: 'tests',
+fn: function (){
+var self=this;
+function $HLCodeWidget(){return globals.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st($HLCodeWidget())._pcKeyMap())._isKindOf_($HashedCollection());
+$ctx1.sendIdx["isKindOf:"]=1;
+self._assert_($1);
+$ctx1.sendIdx["assert:"]=1;
+self._assert_(_st(_st($HLCodeWidget())._macKeyMap())._isKindOf_($HashedCollection()));
+return self}, function($ctx1) {$ctx1.fill(self,"testKeyMap",{},globals.HLCodeWidgetTest)})},
+args: [],
+source: "testKeyMap\x0a\x09\x22Key maps are a collection of associations.\x22\x0a\x09self assert: (HLCodeWidget pcKeyMap isKindOf: HashedCollection).\x0a\x09self assert: (HLCodeWidget macKeyMap isKindOf: HashedCollection)",
+messageSends: ["assert:", "isKindOf:", "pcKeyMap", "macKeyMap"],
+referencedClasses: ["HLCodeWidget", "HashedCollection"]
+}),
+globals.HLCodeWidgetTest);
+
+
+});

src/Helios-Workspace-Tests.st

@@ -0,0 +1,13 @@
+Smalltalk createPackage: 'Helios-Workspace-Tests'!
+TestCase subclass: #HLCodeWidgetTest
+	instanceVariableNames: ''
+	package: 'Helios-Workspace-Tests'!
+
+!HLCodeWidgetTest methodsFor: 'tests'!
+
+testKeyMap
+	"Key maps are a collection of associations."
+	self assert: (HLCodeWidget pcKeyMap isKindOf: HashedCollection).
+	self assert: (HLCodeWidget macKeyMap isKindOf: HashedCollection)
+! !
+

src/Helios-Workspace.js

@@ -0,0 +1,2372 @@
+define("helios/Helios-Workspace", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "helios/Helios-Core"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Workspace');
+smalltalk.packages["Helios-Workspace"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLCodeModel', globals.Object, ['announcer', 'environment', 'receiver'], 'Helios-Workspace');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "announcer",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $Announcer(){return globals.Announcer||(typeof Announcer=="undefined"?nil:Announcer)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@announcer"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@announcer"]=_st($Announcer())._new();
+$1=self["@announcer"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"announcer",{},globals.HLCodeModel)})},
+args: [],
+source: "announcer\x0a\x09^ announcer ifNil: [ announcer := Announcer new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["Announcer"]
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "browse:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(anObject)._browse();
+return self}, function($ctx1) {$ctx1.fill(self,"browse:",{anObject:anObject},globals.HLCodeModel)})},
+args: ["anObject"],
+source: "browse: anObject\x0a\x09anObject browse",
+messageSends: ["browse"],
+referencedClasses: []
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "defaultReceiver",
+protocol: 'defaults',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._environment())._doItReceiver();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"defaultReceiver",{},globals.HLCodeModel)})},
+args: [],
+source: "defaultReceiver\x0a\x09^ self environment doItReceiver",
+messageSends: ["doItReceiver", "environment"],
+referencedClasses: []
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doIt:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $ErrorHandler(){return globals.ErrorHandler||(typeof ErrorHandler=="undefined"?nil:ErrorHandler)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._environment())._evaluate_for_(aString,self._receiver());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._tryCatch_((function(e){
+return smalltalk.withContext(function($ctx2) {
+_st($ErrorHandler())._handleError_(e);
+return nil;
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"doIt:",{aString:aString},globals.HLCodeModel)})},
+args: ["aString"],
+source: "doIt: aString\x0a\x09\x22Evaluate aString in the receiver's `environment`.\x0a\x09\x0a\x09Note: Catch any error and handle it manually, bypassing\x0a\x09boot.js behavior to avoid the browser default action on\x0a\x09ctrl+d/ctrl+p.\x0a\x09\x0a\x09See https://github.com/amber-smalltalk/amber/issues/882\x22\x0a\x0a\x09^ [ self environment evaluate: aString for: self receiver ]\x0a\x09\x09tryCatch: [ :e | \x0a\x09\x09\x09ErrorHandler handleError: e.\x0a\x09\x09\x09nil ]",
+messageSends: ["tryCatch:", "evaluate:for:", "environment", "receiver", "handleError:"],
+referencedClasses: ["ErrorHandler"]
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@environment"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1=_st(_st($HLManager())._current())._environment();
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"environment",{},globals.HLCodeModel)})},
+args: [],
+source: "environment\x0a\x09^ environment ifNil: [ HLManager current environment ]",
+messageSends: ["ifNil:", "environment", "current"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "environment:",
+protocol: 'accessing',
+fn: function (anEnvironment){
+var self=this;
+self["@environment"]=anEnvironment;
+return self},
+args: ["anEnvironment"],
+source: "environment: anEnvironment\x0a\x09environment := anEnvironment",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspect:",
+protocol: 'actions',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._environment())._inspect_(anObject);
+return self}, function($ctx1) {$ctx1.fill(self,"inspect:",{anObject:anObject},globals.HLCodeModel)})},
+args: ["anObject"],
+source: "inspect: anObject\x0a\x09self environment inspect: anObject",
+messageSends: ["inspect:", "environment"],
+referencedClasses: []
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "receiver",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@receiver"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@receiver"]=self._defaultReceiver();
+$1=self["@receiver"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"receiver",{},globals.HLCodeModel)})},
+args: [],
+source: "receiver\x0a\x09^ receiver ifNil: [ receiver := self defaultReceiver ]",
+messageSends: ["ifNil:", "defaultReceiver"],
+referencedClasses: []
+}),
+globals.HLCodeModel);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "receiver:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+self["@receiver"]=anObject;
+return self},
+args: ["anObject"],
+source: "receiver: anObject\x0a\x09receiver := anObject",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeModel);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'actions',
+fn: function (anEnvironment){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._environment_(anEnvironment);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{anEnvironment:anEnvironment},globals.HLCodeModel.klass)})},
+args: ["anEnvironment"],
+source: "on: anEnvironment\x0a\x0a\x09^ self new\x0a    \x09environment: anEnvironment;\x0a        yourself",
+messageSends: ["environment:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLCodeModel.klass);
+
+
+smalltalk.addClass('HLCodeWidget', globals.HLWidget, ['model', 'wrapper', 'code', 'editor', 'state'], 'Helios-Workspace');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "announcer",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._announcer();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"announcer",{},globals.HLCodeWidget)})},
+args: [],
+source: "announcer\x0a\x09^ self model announcer",
+messageSends: ["announcer", "model"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "browseIt",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var result;
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+function $ErrorHandler(){return globals.ErrorHandler||(typeof ErrorHandler=="undefined"?nil:ErrorHandler)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+var $early={};
+try {
+result=_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._doIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._on_do_($Error(),(function(exception){
+return smalltalk.withContext(function($ctx2) {
+$1=_st($ErrorHandler())._handleError_(exception);
+throw $early=[$1];
+}, function($ctx2) {$ctx2.fillBlock({exception:exception},$ctx1,2)})}));
+_st(self._model())._browse_(result);
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"browseIt",{result:result},globals.HLCodeWidget)})},
+args: [],
+source: "browseIt\x0a\x09| result |\x0a\x09\x0a\x09result := [ self doIt ] on: Error do: [ :exception | \x0a\x09\x09^ ErrorHandler handleError: exception ].\x0a\x09\x09\x0a\x09self model browse: result",
+messageSends: ["on:do:", "doIt", "handleError:", "browse:", "model"],
+referencedClasses: ["Error", "ErrorHandler"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canHaveFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canHaveFocus\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "clear",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._contents_("");
+return self}, function($ctx1) {$ctx1.fill(self,"clear",{},globals.HLCodeWidget)})},
+args: [],
+source: "clear\x0a\x09self contents: ''",
+messageSends: ["contents:"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "configureEditor",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3;
+$1=self._editor();
+$ctx1.sendIdx["editor"]=1;
+_st($1)._at_put_("amberCodeWidget",self);
+$2=self._editor();
+$ctx1.sendIdx["editor"]=2;
+_st($2)._on_do_("change",(function(){
+return smalltalk.withContext(function($ctx2) {
+return self._onChange();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+_st(_st(self._wrapper())._asJQuery())._on_in_do_("mousedown",".CodeMirror pre",(function(event){
+var position,node;
+return smalltalk.withContext(function($ctx2) {
+$3=_st(event)._at_("ctrlKey");
+if(smalltalk.assert($3)){
+position=_st(self._editor())._coordsChar_(globals.HashedCollection._newFromPairs_(["left",_st(event)._clientX(),"top",_st(event)._clientY()]));
+position;
+self._onCtrlClickAt_(_st(_st(_st(position)._line()).__at(_st(position)._ch())).__plus((1)));
+return _st(event)._preventDefault();
+};
+}, function($ctx2) {$ctx2.fillBlock({event:event,position:position,node:node},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"configureEditor",{},globals.HLCodeWidget)})},
+args: [],
+source: "configureEditor\x0a\x09self editor at: 'amberCodeWidget' put: self.\x0a\x09self editor on: 'change' do: [ self onChange ].\x0a\x0a\x09self wrapper asJQuery on: 'mousedown' in: '.CodeMirror pre' do: [ :event | | position node |\x0a\x09\x09(event at: 'ctrlKey') ifTrue: [\x0a\x09\x09\x09position := self editor coordsChar: #{ \x0a\x09\x09\x09\x09'left' -> event clientX.\x0a\x09\x09\x09\x09'top' -> event clientY\x0a\x09\x09\x09}.\x0a\x09\x09\x09self onCtrlClickAt: (position line @ position ch) + 1.\x0a\x09\x09\x09event preventDefault ] ]",
+messageSends: ["at:put:", "editor", "on:do:", "onChange", "on:in:do:", "asJQuery", "wrapper", "ifTrue:", "at:", "coordsChar:", "clientX", "clientY", "onCtrlClickAt:", "+", "@", "line", "ch", "preventDefault"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "contents",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@editor"])._getValue();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"contents",{},globals.HLCodeWidget)})},
+args: [],
+source: "contents\x0a\x09^ editor getValue",
+messageSends: ["getValue"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "contents:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$receiver;
+_st(self["@editor"])._setValue_(aString);
+$1=self["@state"];
+if(($receiver = $1) == null || $receiver.isNil){
+$1;
+} else {
+self._updateState();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"contents:",{aString:aString},globals.HLCodeWidget)})},
+args: ["aString"],
+source: "contents: aString\x0a\x09editor setValue: aString.\x0a\x09state ifNotNil: [ self updateState ]",
+messageSends: ["setValue:", "ifNotNil:", "updateState"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "currentLine",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@editor"])._getLine_(_st(_st(self["@editor"])._getCursor())._line());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"currentLine",{},globals.HLCodeWidget)})},
+args: [],
+source: "currentLine\x0a    ^editor getLine: (editor getCursor line)",
+messageSends: ["getLine:", "line", "getCursor"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "currentLineOrSelection",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=_st(self["@editor"])._somethingSelected();
+if(smalltalk.assert($2)){
+$1=self._selection();
+} else {
+$1=self._currentLine();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"currentLineOrSelection",{},globals.HLCodeWidget)})},
+args: [],
+source: "currentLineOrSelection\x0a    ^editor somethingSelected\x0a\x09\x09ifFalse: [ self currentLine ]\x0a\x09\x09ifTrue: [ self selection ]",
+messageSends: ["ifFalse:ifTrue:", "somethingSelected", "currentLine", "selection"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "doIt",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var result;
+function $HLDoItExecuted(){return globals.HLDoItExecuted||(typeof HLDoItExecuted=="undefined"?nil:HLDoItExecuted)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._model();
+$ctx1.sendIdx["model"]=1;
+result=_st($1)._doIt_(self._currentLineOrSelection());
+_st(_st(self._model())._announcer())._announce_(_st($HLDoItExecuted())._on_(self["@model"]));
+$2=result;
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"doIt",{result:result},globals.HLCodeWidget)})},
+args: [],
+source: "doIt\x0a\x09| result |\x0a\x0a\x09result := self model doIt: self currentLineOrSelection.\x0a\x09self model announcer announce: (HLDoItExecuted on: model).\x0a\x0a\x09^ result",
+messageSends: ["doIt:", "model", "currentLineOrSelection", "announce:", "announcer", "on:"],
+referencedClasses: ["HLDoItExecuted"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "editor",
+protocol: 'actions',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@editor"];
+return $1;
+},
+args: [],
+source: "editor\x0a\x09^ editor",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "editorOptions",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2="helios.editorTheme"._settingValueIfAbsent_("default");
+$ctx1.sendIdx["settingValueIfAbsent:"]=1;
+$1=globals.HashedCollection._newFromPairs_(["theme",$2,"mode","text/x-stsrc","lineNumbers",true,"enterMode","flat","indentWithTabs",true,"indentUnit",(4),"matchBrackets",true,"electricChars",false,"keyMap","Amber","extraKeys",_st($HashedCollection())._with_(_st("helios.completionKey"._settingValueIfAbsent_("Shift-Space")).__minus_gt("autocomplete"))]);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"editorOptions",{},globals.HLCodeWidget)})},
+args: [],
+source: "editorOptions\x0a\x09^ #{\x0a\x09\x09'theme' -> ('helios.editorTheme' settingValueIfAbsent: 'default').\x0a\x09\x09'mode' -> 'text/x-stsrc'.\x0a        'lineNumbers' -> true.\x0a        'enterMode' -> 'flat'.\x0a        'indentWithTabs' -> true.\x0a\x09\x09'indentUnit' -> 4.\x0a        'matchBrackets' -> true.\x0a        'electricChars' -> false.\x0a\x09\x09'keyMap' -> 'Amber'.\x0a\x09\x09'extraKeys' -> (HashedCollection with: ('helios.completionKey' settingValueIfAbsent: 'Shift-Space') -> 'autocomplete')\x0a\x09}",
+messageSends: ["settingValueIfAbsent:", "with:", "->"],
+referencedClasses: ["HashedCollection"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@editor"])._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLCodeWidget)})},
+args: [],
+source: "focus\x0a\x09editor focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hasFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self["@code"])._asJQuery())._is_(":active");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"hasFocus",{},globals.HLCodeWidget)})},
+args: [],
+source: "hasFocus\x0a\x09^ code asJQuery is: ':active'",
+messageSends: ["is:", "asJQuery"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hasModification",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "hasModification\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "inspectIt",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._inspect_(self._doIt());
+return self}, function($ctx1) {$ctx1.fill(self,"inspectIt",{},globals.HLCodeWidget)})},
+args: [],
+source: "inspectIt\x0a\x09self model inspect: self doIt",
+messageSends: ["inspect:", "model", "doIt"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "messageHintFor:token:",
+protocol: 'hints',
+fn: function (anEditor,aToken){
+var self=this;
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$1=_st(_st(_st(_st(_st($Smalltalk())._vm())._allSelectors())._asArray())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(aToken)._string();
+$ctx2.sendIdx["string"]=1;
+return _st(each)._includesSubString_($2);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._reject_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each).__eq(_st(aToken)._string());
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"messageHintFor:token:",{anEditor:anEditor,aToken:aToken},globals.HLCodeWidget)})},
+args: ["anEditor", "aToken"],
+source: "messageHintFor: anEditor token: aToken\x0a\x09^ (Smalltalk vm allSelectors asArray \x0a\x09\x09select: [ :each | each includesSubString: aToken string ])\x0a\x09\x09reject: [ :each | each = aToken string ]",
+messageSends: ["reject:", "select:", "asArray", "allSelectors", "vm", "includesSubString:", "string", "="],
+referencedClasses: ["Smalltalk"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLCodeModel(){return globals.HLCodeModel||(typeof HLCodeModel=="undefined"?nil:HLCodeModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@model"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@model"]=_st($HLCodeModel())._new();
+$1=self["@model"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLCodeWidget)})},
+args: [],
+source: "model\x0a\x09^ model ifNil: [ model := HLCodeModel new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HLCodeModel"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "model:",
+protocol: 'accessing',
+fn: function (aModel){
+var self=this;
+self["@model"]=aModel;
+return self},
+args: ["aModel"],
+source: "model: aModel\x0a\x09model := aModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "navigateTo:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $Finder(){return globals.Finder||(typeof Finder=="undefined"?nil:Finder)}
+return smalltalk.withContext(function($ctx1) { 
+_st($Finder())._findString_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"navigateTo:",{aString:aString},globals.HLCodeWidget)})},
+args: ["aString"],
+source: "navigateTo: aString\x0a\x09Finder findString: aString",
+messageSends: ["findString:"],
+referencedClasses: ["Finder"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "navigateToReference:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+function $HLReferences(){return globals.HLReferences||(typeof HLReferences=="undefined"?nil:HLReferences)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st($HLReferences())._openAsTab())._search_(aString);
+return self}, function($ctx1) {$ctx1.fill(self,"navigateToReference:",{aString:aString},globals.HLCodeWidget)})},
+args: ["aString"],
+source: "navigateToReference: aString\x0a\x09(HLReferences openAsTab)\x0a\x09\x09search: aString",
+messageSends: ["search:", "openAsTab"],
+referencedClasses: ["HLReferences"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onChange",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._updateState();
+return self}, function($ctx1) {$ctx1.fill(self,"onChange",{},globals.HLCodeWidget)})},
+args: [],
+source: "onChange\x0a\x09self updateState",
+messageSends: ["updateState"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onCtrlClickAt:",
+protocol: 'reactions',
+fn: function (aPoint){
+var self=this;
+var ast,node;
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+return smalltalk.withContext(function($ctx1) { 
+var $early={};
+try {
+ast=_st((function(){
+return smalltalk.withContext(function($ctx2) {
+return _st($Smalltalk())._parse_(_st(self._editor())._getValue());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._on_do_($Error(),(function(error){
+throw $early=[self];
+}));
+node=_st(ast)._navigationNodeAt_ifAbsent_(aPoint,(function(){
+throw $early=[nil];
+}));
+self._navigateTo_(_st(node)._navigationLink());
+return self}
+catch(e) {if(e===$early)return e[0]; throw e}
+}, function($ctx1) {$ctx1.fill(self,"onCtrlClickAt:",{aPoint:aPoint,ast:ast,node:node},globals.HLCodeWidget)})},
+args: ["aPoint"],
+source: "onCtrlClickAt: aPoint\x0a\x09| ast node |\x0a\x09\x0a\x09ast := [ Smalltalk parse: self editor getValue ] \x0a\x09\x09on: Error \x0a\x09\x09do: [ :error | ^ self ].\x0a\x09\x0a\x09node := ast \x0a\x09\x09navigationNodeAt: aPoint \x0a\x09\x09ifAbsent: [ ^ nil ].\x0a\x09\x09\x0a\x09self navigateTo: node navigationLink",
+messageSends: ["on:do:", "parse:", "getValue", "editor", "navigationNodeAt:ifAbsent:", "navigateTo:", "navigationLink"],
+referencedClasses: ["Smalltalk", "Error"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onInspectIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._inspectIt();
+return self}, function($ctx1) {$ctx1.fill(self,"onInspectIt",{},globals.HLCodeWidget)})},
+args: [],
+source: "onInspectIt\x0a\x0a\x09self inspectIt",
+messageSends: ["inspectIt"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPrintIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._printIt();
+return self}, function($ctx1) {$ctx1.fill(self,"onPrintIt",{},globals.HLCodeWidget)})},
+args: [],
+source: "onPrintIt\x0a\x0a\x09self printIt",
+messageSends: ["printIt"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSaveIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "onSaveIt\x0a\x09\x22I do not do anything\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "print:",
+protocol: 'actions',
+fn: function (aString){
+var self=this;
+var start,stop,currentLine;
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$5,$6,$7,$8,$9,$10,$12,$11;
+$1=_st(self["@editor"])._getCursor_(false);
+$ctx1.sendIdx["getCursor:"]=1;
+currentLine=_st($1)._line();
+start=_st($HashedCollection())._new();
+$ctx1.sendIdx["new"]=1;
+_st(start)._at_put_("line",currentLine);
+$ctx1.sendIdx["at:put:"]=1;
+$2=start;
+$4=_st(self["@editor"])._getCursor_(false);
+$ctx1.sendIdx["getCursor:"]=2;
+$3=_st($4)._ch();
+_st($2)._at_put_("ch",$3);
+$ctx1.sendIdx["at:put:"]=2;
+$5=_st(self["@editor"])._getSelection();
+$ctx1.sendIdx["getSelection"]=1;
+_st($5)._ifEmpty_((function(){
+return smalltalk.withContext(function($ctx2) {
+$6=start;
+$7=_st(_st(self["@editor"])._getLine_(currentLine))._size();
+$ctx2.sendIdx["size"]=1;
+_st($6)._at_put_("ch",$7);
+$ctx2.sendIdx["at:put:"]=3;
+return _st(self["@editor"])._setSelection_end_(globals.HashedCollection._newFromPairs_(["line",currentLine,"ch",(0)]),start);
+$ctx2.sendIdx["setSelection:end:"]=1;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+stop=_st($HashedCollection())._new();
+_st(stop)._at_put_("line",currentLine);
+$ctx1.sendIdx["at:put:"]=4;
+$8=stop;
+$9=_st(_st(_st(start)._at_("ch")).__plus(_st(aString)._size())).__plus((2));
+$ctx1.sendIdx["+"]=1;
+_st($8)._at_put_("ch",$9);
+$10=self["@editor"];
+$12=_st(_st(_st(self["@editor"])._getSelection()).__comma(" ")).__comma(aString);
+$ctx1.sendIdx[","]=2;
+$11=_st($12).__comma(" ");
+$ctx1.sendIdx[","]=1;
+_st($10)._replaceSelection_($11);
+_st(self["@editor"])._setCursor_(_st(self["@editor"])._getCursor_(true));
+_st(self["@editor"])._setSelection_end_(stop,start);
+return self}, function($ctx1) {$ctx1.fill(self,"print:",{aString:aString,start:start,stop:stop,currentLine:currentLine},globals.HLCodeWidget)})},
+args: ["aString"],
+source: "print: aString\x0a\x09| start stop currentLine |\x0a    currentLine := (editor getCursor: false) line.\x0a\x09start := HashedCollection new.\x0a\x09start at: 'line' put: currentLine.\x0a\x09start at: 'ch' put: (editor getCursor: false) ch.\x0a    (editor getSelection) ifEmpty: [\x0a    \x09\x22select current line if selection is empty\x22\x0a    \x09start at: 'ch' put: (editor getLine: currentLine) size.\x0a        editor setSelection: #{'line' -> currentLine. 'ch' -> 0} end: start.\x0a    ].\x0a\x09stop := HashedCollection new.\x0a\x09stop at: 'line' put: currentLine.\x0a\x09stop at: 'ch' put: ((start at: 'ch') + aString size + 2).\x0a\x0a\x09editor replaceSelection: (editor getSelection, ' ', aString, ' ').\x0a\x09editor setCursor: (editor getCursor: true).\x0a\x09editor setSelection: stop end: start",
+messageSends: ["line", "getCursor:", "new", "at:put:", "ch", "ifEmpty:", "getSelection", "size", "getLine:", "setSelection:end:", "+", "at:", "replaceSelection:", ",", "setCursor:"],
+referencedClasses: ["HashedCollection"]
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "printIt",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._print_(_st(self._doIt())._printString());
+return self}, function($ctx1) {$ctx1.fill(self,"printIt",{},globals.HLCodeWidget)})},
+args: [],
+source: "printIt\x0a\x09self print: self doIt printString",
+messageSends: ["print:", "printString", "doIt"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "receiver",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._model())._receiver();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"receiver",{},globals.HLCodeWidget)})},
+args: [],
+source: "receiver\x0a\x09^ self model receiver",
+messageSends: ["receiver", "model"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "receiver:",
+protocol: 'accessing',
+fn: function (anObject){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._receiver_(anObject);
+return self}, function($ctx1) {$ctx1.fill(self,"receiver:",{anObject:anObject},globals.HLCodeWidget)})},
+args: ["anObject"],
+source: "receiver: anObject\x0a\x09self model receiver: anObject",
+messageSends: ["receiver:", "model"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5,$6,$7,$8;
+$1=_st(html)._button();
+$ctx1.sendIdx["button"]=1;
+_st($1)._class_("button");
+$ctx1.sendIdx["class:"]=1;
+_st($1)._with_("DoIt");
+$ctx1.sendIdx["with:"]=1;
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._doIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["onClick:"]=1;
+$3=_st(html)._button();
+$ctx1.sendIdx["button"]=2;
+_st($3)._class_("button");
+$ctx1.sendIdx["class:"]=2;
+_st($3)._with_("PrintIt");
+$ctx1.sendIdx["with:"]=2;
+$4=_st($3)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._printIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+$ctx1.sendIdx["onClick:"]=2;
+$5=_st(html)._button();
+$ctx1.sendIdx["button"]=3;
+_st($5)._class_("button");
+$ctx1.sendIdx["class:"]=3;
+_st($5)._with_("InspectIt");
+$ctx1.sendIdx["with:"]=3;
+$6=_st($5)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._inspectIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
+$ctx1.sendIdx["onClick:"]=3;
+$7=_st(html)._button();
+_st($7)._class_("button");
+_st($7)._with_("BrowseIt");
+$8=_st($7)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._browseIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},globals.HLCodeWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09html button \x0a\x09\x09class: 'button';\x0a\x09\x09with: 'DoIt';\x0a\x09\x09onClick: [ self doIt ].\x0a\x09html button \x0a\x09\x09class: 'button';\x0a\x09\x09with: 'PrintIt';\x0a\x09\x09onClick: [ self printIt ].\x0a\x09html button \x0a\x09\x09class: 'button';\x0a\x09\x09with: 'InspectIt';\x0a\x09\x09onClick: [ self inspectIt ].\x0a\x09html button \x0a\x09\x09class: 'button';\x0a\x09\x09with: 'BrowseIt';\x0a\x09\x09onClick: [ self browseIt ]",
+messageSends: ["class:", "button", "with:", "onClick:", "doIt", "printIt", "inspectIt", "browseIt"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5,$6;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._class_("editor");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+self["@code"]=_st(html)._textarea();
+return self["@code"];
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+$3=_st(html)._div();
+$ctx1.sendIdx["div"]=2;
+self["@state"]=_st($3)._class_("state");
+$ctx1.sendIdx["class:"]=2;
+$4=_st(html)._div();
+_st($4)._class_("buttons_bar");
+$5=_st($4)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._renderButtonsOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+self._setEditorOn_(_st(self["@code"])._element());
+self._configureEditor();
+$6=self._updateState();
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLCodeWidget)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html div class: 'editor'; with: [\x0a\x09\x09code := html textarea ].\x0a\x09state := html div class: 'state'.\x0a\x09\x0a\x09html div \x0a\x09\x09class: 'buttons_bar';\x0a\x09\x09with: [ self renderButtonsOn: html ].\x0a\x09\x0a\x09self \x0a\x09\x09setEditorOn: code element;\x0a\x09\x09configureEditor;\x0a\x09\x09updateState",
+messageSends: ["class:", "div", "with:", "textarea", "renderButtonsOn:", "setEditorOn:", "element", "configureEditor", "updateState"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "saveIt",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "saveIt\x0a\x09\x22I do not do anything\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selection",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self["@editor"])._getSelection();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selection",{},globals.HLCodeWidget)})},
+args: [],
+source: "selection\x0a\x09^editor getSelection",
+messageSends: ["getSelection"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectionEnd",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self["@code"])._element())._selectionEnd();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectionEnd",{},globals.HLCodeWidget)})},
+args: [],
+source: "selectionEnd\x0a   ^code element selectionEnd",
+messageSends: ["selectionEnd", "element"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectionEnd:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self["@code"])._element())._selectionEnd_(anInteger);
+return self}, function($ctx1) {$ctx1.fill(self,"selectionEnd:",{anInteger:anInteger},globals.HLCodeWidget)})},
+args: ["anInteger"],
+source: "selectionEnd: anInteger\x0a   code element selectionEnd: anInteger",
+messageSends: ["selectionEnd:", "element"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectionStart",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self["@code"])._element())._selectionStart();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selectionStart",{},globals.HLCodeWidget)})},
+args: [],
+source: "selectionStart\x0a   ^code element selectionStart",
+messageSends: ["selectionStart", "element"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "selectionStart:",
+protocol: 'accessing',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self["@code"])._element())._selectionStart_(anInteger);
+return self}, function($ctx1) {$ctx1.fill(self,"selectionStart:",{anInteger:anInteger},globals.HLCodeWidget)})},
+args: ["anInteger"],
+source: "selectionStart: anInteger\x0a   code element selectionStart: anInteger",
+messageSends: ["selectionStart:", "element"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setEditorOn:",
+protocol: 'actions',
+fn: function (aTextarea){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self['@editor'] = CodeMirror.fromTextArea(aTextarea, self._editorOptions());
+return self}, function($ctx1) {$ctx1.fill(self,"setEditorOn:",{aTextarea:aTextarea},globals.HLCodeWidget)})},
+args: ["aTextarea"],
+source: "setEditorOn: aTextarea\x0a\x09<self['@editor'] = CodeMirror.fromTextArea(aTextarea, self._editorOptions())>",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "updateState",
+protocol: 'updating',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._hasModification();
+if(smalltalk.assert($1)){
+$2=_st(self["@state"])._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+_st($2)._addClass_("modified");
+} else {
+_st(_st(self["@state"])._asJQuery())._removeClass_("modified");
+};
+return self}, function($ctx1) {$ctx1.fill(self,"updateState",{},globals.HLCodeWidget)})},
+args: [],
+source: "updateState\x0a\x09self hasModification \x0a\x09\x09ifTrue: [ state asJQuery addClass: 'modified' ]\x0a\x09\x09ifFalse: [ state asJQuery removeClass: 'modified' ]",
+messageSends: ["ifTrue:ifFalse:", "hasModification", "addClass:", "asJQuery", "removeClass:"],
+referencedClasses: []
+}),
+globals.HLCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variableHintFor:token:",
+protocol: 'hints',
+fn: function (anEditor,aToken){
+var self=this;
+var variables,classNames,pseudoVariables;
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1,$9,$8,$7,$6,$10,$5,$4;
+$3=_st(_st(_st(anEditor)._display())._wrapper())._asJQuery();
+$ctx1.sendIdx["asJQuery"]=1;
+$2=_st($3)._find_("span.cm-variable");
+$1=_st($2)._get();
+variables=_st($1)._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(each)._asJQuery())._html();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
+$ctx1.sendIdx["collect:"]=1;
+classNames=_st(_st($Smalltalk())._classes())._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each)._name();
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
+pseudoVariables=_st($Smalltalk())._pseudoVariableNames();
+$9=_st(_st(variables).__comma(classNames)).__comma(pseudoVariables);
+$ctx1.sendIdx[","]=1;
+$8=_st($9)._asSet();
+$7=_st($8)._asArray();
+$6=_st($7)._sort();
+$5=_st($6)._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+$10=_st(aToken)._string();
+$ctx2.sendIdx["string"]=1;
+return _st(each)._includesSubString_($10);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})}));
+$4=_st($5)._reject_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each).__eq(_st(aToken)._string());
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,4)})}));
+return $4;
+}, function($ctx1) {$ctx1.fill(self,"variableHintFor:token:",{anEditor:anEditor,aToken:aToken,variables:variables,classNames:classNames,pseudoVariables:pseudoVariables},globals.HLCodeWidget)})},
+args: ["anEditor", "aToken"],
+source: "variableHintFor: anEditor token: aToken\x0a\x09| variables classNames pseudoVariables |\x0a\x09\x0a\x09variables := (anEditor display wrapper asJQuery find: 'span.cm-variable') get\x0a\x09\x09collect: [ :each | each asJQuery html ].\x0a\x09\x0a\x09classNames := Smalltalk classes collect: [ :each | each name ].\x0a\x09pseudoVariables := Smalltalk pseudoVariableNames.\x0a\x09\x0a\x09^ ((variables, classNames, pseudoVariables) asSet asArray sort\x0a\x09\x09select: [ :each | each includesSubString: aToken string ])\x0a\x09\x09reject: [ :each | each = aToken string ]",
+messageSends: ["collect:", "get", "find:", "asJQuery", "wrapper", "display", "html", "classes", "name", "pseudoVariableNames", "reject:", "select:", "sort", "asArray", "asSet", ",", "includesSubString:", "string", "="],
+referencedClasses: ["Smalltalk"]
+}),
+globals.HLCodeWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hintFor:options:",
+protocol: 'hints',
+fn: function (anEditor,options){
+var self=this;
+var cursor,token,completions;
+function $CodeMirror(){return globals.CodeMirror||(typeof CodeMirror=="undefined"?nil:CodeMirror)}
+function $HLCodeWidget(){return globals.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$4,$3,$2,$5,$7,$9,$10,$8,$6;
+cursor=_st(anEditor)._getCursor();
+token=_st(anEditor)._getTokenAt_(cursor);
+$1=token;
+$4=_st($CodeMirror())._basicAt_("innerMode");
+$ctx1.sendIdx["basicAt:"]=1;
+$3=_st($4)._value_value_(_st(anEditor)._getMode(),_st(token)._at_("state"));
+$ctx1.sendIdx["value:value:"]=1;
+$2=_st($3)._state();
+_st($1)._at_put_("state",$2);
+$5=_st(_st(token)._type()).__eq("variable");
+if(smalltalk.assert($5)){
+completions=_st($HLCodeWidget())._variableHintFor_token_(anEditor,token);
+} else {
+completions=_st($HLCodeWidget())._messageHintFor_token_(anEditor,token);
+};
+$7=completions;
+$9=_st($CodeMirror())._basicAt_("Pos");
+$ctx1.sendIdx["basicAt:"]=2;
+$10=_st(cursor)._line();
+$ctx1.sendIdx["line"]=1;
+$8=_st($9)._value_value_($10,_st(token)._end());
+$ctx1.sendIdx["value:value:"]=2;
+$6=globals.HashedCollection._newFromPairs_(["list",$7,"from",$8,"to",_st(_st($CodeMirror())._basicAt_("Pos"))._value_value_(_st(cursor)._line(),_st(token)._start())]);
+return $6;
+}, function($ctx1) {$ctx1.fill(self,"hintFor:options:",{anEditor:anEditor,options:options,cursor:cursor,token:token,completions:completions},globals.HLCodeWidget.klass)})},
+args: ["anEditor", "options"],
+source: "hintFor: anEditor options: options\x0a\x09| cursor token completions |\x0a\x09\x0a\x09cursor := anEditor getCursor.\x0a\x09token := anEditor getTokenAt: cursor.\x0a\x09token at: 'state' put: ((CodeMirror basicAt: 'innerMode')\x0a\x09\x09value: anEditor getMode value: (token at: 'state')) state.\x0a\x09\x0a\x09completions := token type = 'variable' \x0a\x09\x09ifTrue: [ HLCodeWidget variableHintFor: anEditor token: token ]\x0a\x09\x09ifFalse: [ HLCodeWidget messageHintFor: anEditor token: token ].\x0a\x09\x0a\x09^ #{\x0a\x09\x09'list' -> completions.\x0a\x09\x09'from' -> ((CodeMirror basicAt: 'Pos') value: cursor line value: token end).\x0a\x09\x09'to' -> ((CodeMirror basicAt: 'Pos') value: cursor line value: token start)\x0a\x09}",
+messageSends: ["getCursor", "getTokenAt:", "at:put:", "state", "value:value:", "basicAt:", "getMode", "at:", "ifTrue:ifFalse:", "=", "type", "variableHintFor:token:", "messageHintFor:token:", "line", "end", "start"],
+referencedClasses: ["CodeMirror", "HLCodeWidget"]
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "initialize",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+($ctx1.supercall = true, globals.HLCodeWidget.klass.superclass.fn.prototype._initialize.apply(_st(self), []));
+$ctx1.supercall = false;
+self._setupCodeMirror();
+self._setupCommands();
+$1=self._setupKeyMaps();
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLCodeWidget.klass)})},
+args: [],
+source: "initialize\x0a\x09super initialize.\x0a\x09self \x0a\x09\x09setupCodeMirror;\x0a\x09\x09setupCommands;\x0a\x09\x09setupKeyMaps.",
+messageSends: ["initialize", "setupCodeMirror", "setupCommands", "setupKeyMaps"],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "keyMap",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=_st(_st(_st($HLManager())._current())._keyBinder())._systemIsMac();
+if(smalltalk.assert($2)){
+$1=self._macKeyMap();
+} else {
+$1=self._pcKeyMap();
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"keyMap",{},globals.HLCodeWidget.klass)})},
+args: [],
+source: "keyMap\x0a\x09^ HLManager current keyBinder systemIsMac\x0a\x09\x09ifTrue: [ self macKeyMap ]\x0a\x09\x09ifFalse: [ self pcKeyMap ]",
+messageSends: ["ifTrue:ifFalse:", "systemIsMac", "keyBinder", "current", "macKeyMap", "pcKeyMap"],
+referencedClasses: ["HLManager"]
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "macKeyMap",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=globals.HashedCollection._newFromPairs_(["Alt-Backspace","delWordBefore","Alt-Delete","delWordAfter","Alt-Left","goWordLeft","Alt-Right","goWordRight","Cmd-A","selectAll","Cmd-Alt-F","replace","Cmd-D","doIt","Cmd-B","browseIt","Cmd-Down","goDocEnd","Cmd-End","goDocEnd","Cmd-F","find","Cmd-G","findNext","Cmd-I","inspectIt","Cmd-Left","goLineStart","Cmd-P","printIt","Cmd-Right","goLineEnd","Cmd-S","saveIt","Cmd-Up","goDocStart","Cmd-Y","redo","Cmd-Z","undo","Cmd-[","indentLess","Cmd-]","indentMore","Ctrl-Alt-Backspace","delWordAfter","Shift-Cmd-Alt-F","replaceAll","Shift-Cmd-G","findPrev","Shift-Cmd-Z","redo","fallthrough",["basic","emacsy"]]);
+return $1;
+},
+args: [],
+source: "macKeyMap\x0a\x09^ #{\x0a\x09\x09'Alt-Backspace'\x09\x09\x09-> 'delWordBefore'.\x0a\x09\x09'Alt-Delete'\x09\x09\x09-> 'delWordAfter'. \x0a\x09\x09'Alt-Left'\x09\x09\x09\x09-> 'goWordLeft'.\x0a\x09\x09'Alt-Right'\x09\x09\x09\x09-> 'goWordRight'. \x0a\x09\x09'Cmd-A'\x09\x09\x09\x09\x09-> 'selectAll'. \x0a\x09\x09'Cmd-Alt-F'\x09\x09\x09\x09-> 'replace'. \x0a\x09\x09'Cmd-D'\x09\x09\x09\x09\x09-> 'doIt'. \x0a\x09\x09'Cmd-B'\x09\x09\x09\x09\x09-> 'browseIt'. \x0a\x09\x09'Cmd-Down'\x09\x09\x09\x09-> 'goDocEnd'. \x0a\x09\x09'Cmd-End'\x09\x09\x09\x09-> 'goDocEnd'. \x0a\x09\x09'Cmd-F'\x09\x09\x09\x09\x09-> 'find'.\x0a\x09\x09'Cmd-G'\x09\x09\x09\x09\x09-> 'findNext'. \x0a\x09\x09'Cmd-I'\x09\x09\x09\x09\x09-> 'inspectIt'. \x0a\x09\x09'Cmd-Left'\x09\x09\x09\x09-> 'goLineStart'. \x0a\x09\x09'Cmd-P'\x09\x09\x09\x09\x09-> 'printIt'. \x0a\x09\x09'Cmd-Right'\x09\x09\x09\x09-> 'goLineEnd'. \x0a\x09\x09'Cmd-S'\x09\x09\x09\x09\x09-> 'saveIt'. \x0a\x09\x09'Cmd-Up'\x09\x09\x09\x09-> 'goDocStart'. \x0a\x09\x09'Cmd-Y'\x09\x09\x09\x09\x09-> 'redo'.\x0a\x09\x09'Cmd-Z'\x09\x09\x09\x09\x09-> 'undo'. \x0a\x09\x09'Cmd-['\x09\x09\x09\x09\x09-> 'indentLess'. \x0a\x09\x09'Cmd-]'\x09\x09\x09\x09\x09-> 'indentMore'.\x0a\x09\x09'Ctrl-Alt-Backspace'\x09-> 'delWordAfter'. \x0a\x09\x09'Shift-Cmd-Alt-F'\x09\x09-> 'replaceAll'.\x0a\x09\x09'Shift-Cmd-G'\x09\x09\x09-> 'findPrev'. \x0a\x09\x09'Shift-Cmd-Z'\x09\x09\x09-> 'redo'. \x0a    \x09'fallthrough' \x09\x09\x09-> { 'basic'. 'emacsy' }\x0a  }",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "messageHintFor:token:",
+protocol: 'hints',
+fn: function (anEditor,aToken){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(anEditor)._at_("amberCodeWidget"))._messageHintFor_token_(anEditor,aToken);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"messageHintFor:token:",{anEditor:anEditor,aToken:aToken},globals.HLCodeWidget.klass)})},
+args: ["anEditor", "aToken"],
+source: "messageHintFor: anEditor token: aToken\x0a\x09^ (anEditor at: 'amberCodeWidget')\x0a\x09\x09messageHintFor: anEditor token: aToken",
+messageSends: ["messageHintFor:token:", "at:"],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "pcKeyMap",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=globals.HashedCollection._newFromPairs_(["Alt-Left","goLineStart","Alt-Right","goLineEnd","Alt-Up","goDocStart","Ctrl-A","selectAll","Ctrl-Backspace","delWordBefore","Ctrl-D","doIt","Ctrl-B","browseIt","Ctrl-Delete","delWordAfter","Ctrl-Down","goDocEnd","Ctrl-End","goDocEnd","Ctrl-F","find","Ctrl-G","findNext","Ctrl-I","inspectIt","Ctrl-Home","goDocStart","Ctrl-Left","goWordLeft","Ctrl-P","printIt","Ctrl-Right","goWordRight","Ctrl-S","saveIt","Ctrl-Y","redo","Ctrl-Z","undo","Ctrl-[","indentLess","Ctrl-]","indentMore","Shift-Ctrl-F","replace","Shift-Ctrl-G","findPrev","Shift-Ctrl-R","replaceAll","Shift-Ctrl-Z","redo","fallthrough",["basic"]]);
+return $1;
+},
+args: [],
+source: "pcKeyMap\x0a\x09^ #{\x0a\x09\x09'Alt-Left' -> \x09\x09'goLineStart'. \x0a\x09\x09'Alt-Right' -> \x09\x09'goLineEnd'.\x0a\x09\x09'Alt-Up' -> \x09\x09'goDocStart'. \x0a\x09\x09'Ctrl-A' -> \x09\x09'selectAll'. \x0a\x09\x09'Ctrl-Backspace' -> 'delWordBefore'. \x0a\x09\x09'Ctrl-D' -> \x09\x09'doIt'. \x0a\x09\x09'Ctrl-B' -> \x09\x09'browseIt'. \x0a\x09\x09'Ctrl-Delete' -> \x09\x09'delWordAfter'. \x0a\x09\x09'Ctrl-Down' -> \x09\x09'goDocEnd'.\x0a\x09\x09'Ctrl-End' -> \x09\x09'goDocEnd'. \x0a\x09\x09'Ctrl-F' -> \x09\x09'find'.\x0a\x09\x09'Ctrl-G' -> \x09\x09'findNext'. \x0a\x09\x09'Ctrl-I' -> \x09\x09'inspectIt'.\x0a\x09\x09'Ctrl-Home' -> \x09\x09'goDocStart'. \x0a\x09\x09'Ctrl-Left' -> \x09\x09'goWordLeft'. \x0a\x09\x09'Ctrl-P' -> \x09\x09'printIt'.\x0a\x09\x09'Ctrl-Right' -> \x09'goWordRight'. \x0a\x09\x09'Ctrl-S' -> \x09\x09'saveIt'. \x0a\x09\x09'Ctrl-Y' -> \x09\x09'redo'.\x0a\x09\x09'Ctrl-Z' -> \x09\x09'undo'. \x0a\x09\x09'Ctrl-[' -> \x09\x09'indentLess'. \x0a\x09\x09'Ctrl-]' -> \x09\x09'indentMore'.\x0a\x09\x09'Shift-Ctrl-F' -> \x09'replace'. \x0a\x09\x09'Shift-Ctrl-G' -> \x09'findPrev'. \x0a\x09\x09'Shift-Ctrl-R' -> \x09'replaceAll'.\x0a\x09\x09'Shift-Ctrl-Z' -> \x09'redo'. \x0a\x09\x09'fallthrough' -> \x09#('basic')\x0a}",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupCodeMirror",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+ 
+		CodeMirror.keyMap.default.fallthrough = ["basic"];
+		CodeMirror.commands.autocomplete = function(cm) {
+			CodeMirror.showHint(cm, self._hintFor_options_);
+		}
+	;
+return self}, function($ctx1) {$ctx1.fill(self,"setupCodeMirror",{},globals.HLCodeWidget.klass)})},
+args: [],
+source: "setupCodeMirror\x0a\x09< \x0a\x09\x09CodeMirror.keyMap.default.fallthrough = [\x22basic\x22];\x0a\x09\x09CodeMirror.commands.autocomplete = function(cm) {\x0a\x09\x09\x09CodeMirror.showHint(cm, self._hintFor_options_);\x0a\x09\x09}\x0a\x09>",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupCommands",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+function $CodeMirror(){return globals.CodeMirror||(typeof CodeMirror=="undefined"?nil:CodeMirror)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$5,$6;
+$1=_st($CodeMirror())._basicAt_("commands");
+_st($1)._at_put_("doIt",(function(cm){
+return smalltalk.withContext(function($ctx2) {
+$2=_st(cm)._amberCodeWidget();
+$ctx2.sendIdx["amberCodeWidget"]=1;
+return _st($2)._doIt();
+}, function($ctx2) {$ctx2.fillBlock({cm:cm},$ctx1,1)})}));
+$ctx1.sendIdx["at:put:"]=1;
+_st($1)._at_put_("inspectIt",(function(cm){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(cm)._amberCodeWidget();
+$ctx2.sendIdx["amberCodeWidget"]=2;
+return _st($3)._inspectIt();
+}, function($ctx2) {$ctx2.fillBlock({cm:cm},$ctx1,2)})}));
+$ctx1.sendIdx["at:put:"]=2;
+_st($1)._at_put_("printIt",(function(cm){
+return smalltalk.withContext(function($ctx2) {
+$4=_st(cm)._amberCodeWidget();
+$ctx2.sendIdx["amberCodeWidget"]=3;
+return _st($4)._printIt();
+}, function($ctx2) {$ctx2.fillBlock({cm:cm},$ctx1,3)})}));
+$ctx1.sendIdx["at:put:"]=3;
+_st($1)._at_put_("saveIt",(function(cm){
+return smalltalk.withContext(function($ctx2) {
+$5=_st(cm)._amberCodeWidget();
+$ctx2.sendIdx["amberCodeWidget"]=4;
+return _st($5)._saveIt();
+}, function($ctx2) {$ctx2.fillBlock({cm:cm},$ctx1,4)})}));
+$ctx1.sendIdx["at:put:"]=4;
+$6=_st($1)._at_put_("browseIt",(function(cm){
+return smalltalk.withContext(function($ctx2) {
+return _st(_st(cm)._amberCodeWidget())._browseIt();
+}, function($ctx2) {$ctx2.fillBlock({cm:cm},$ctx1,5)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"setupCommands",{},globals.HLCodeWidget.klass)})},
+args: [],
+source: "setupCommands\x0a\x09(CodeMirror basicAt: 'commands') \x0a\x09\x09at: 'doIt' put: [ :cm | cm amberCodeWidget doIt ];\x0a\x09\x09at: 'inspectIt' put: [ :cm | cm amberCodeWidget inspectIt ];\x0a\x09\x09at: 'printIt' put: [ :cm | cm amberCodeWidget printIt ];\x0a\x09\x09at: 'saveIt' put: [ :cm | cm amberCodeWidget saveIt ];\x0a\x09\x09at: 'browseIt' put: [ :cm | cm amberCodeWidget browseIt ]",
+messageSends: ["at:put:", "basicAt:", "doIt", "amberCodeWidget", "inspectIt", "printIt", "saveIt", "browseIt"],
+referencedClasses: ["CodeMirror"]
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setupKeyMaps",
+protocol: 'initialization',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+CodeMirror.keyMap['Amber'] = self._keyMap();
+return self}, function($ctx1) {$ctx1.fill(self,"setupKeyMaps",{},globals.HLCodeWidget.klass)})},
+args: [],
+source: "setupKeyMaps\x0a\x09<CodeMirror.keyMap['Amber'] = self._keyMap()>",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "variableHintFor:token:",
+protocol: 'hints',
+fn: function (anEditor,aToken){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(anEditor)._at_("amberCodeWidget"))._variableHintFor_token_(anEditor,aToken);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"variableHintFor:token:",{anEditor:anEditor,aToken:aToken},globals.HLCodeWidget.klass)})},
+args: ["anEditor", "aToken"],
+source: "variableHintFor: anEditor token: aToken\x0a\x09^ (anEditor at: 'amberCodeWidget')\x0a\x09\x09variableHintFor: anEditor token: aToken",
+messageSends: ["variableHintFor:token:", "at:"],
+referencedClasses: []
+}),
+globals.HLCodeWidget.klass);
+
+
+smalltalk.addClass('HLNavigationCodeWidget', globals.HLCodeWidget, ['methodContents'], 'Helios-Workspace');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "configureEditor",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLNavigationCodeWidget.superclass.fn.prototype._configureEditor.apply(_st(self), []));
+$ctx1.supercall = false;
+self._contents_(self._methodContents());
+return self}, function($ctx1) {$ctx1.fill(self,"configureEditor",{},globals.HLNavigationCodeWidget)})},
+args: [],
+source: "configureEditor\x0a\x09super configureEditor.\x0a\x09self contents: self methodContents",
+messageSends: ["configureEditor", "contents:", "methodContents"],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "contents:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._methodContents_(aString);
+($ctx1.supercall = true, globals.HLNavigationCodeWidget.superclass.fn.prototype._contents_.apply(_st(self), [aString]));
+$ctx1.supercall = false;
+return self}, function($ctx1) {$ctx1.fill(self,"contents:",{aString:aString},globals.HLNavigationCodeWidget)})},
+args: ["aString"],
+source: "contents: aString\x0a\x09self methodContents: aString.\x0a\x09super contents: aString",
+messageSends: ["methodContents:", "contents:"],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "hasModification",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self._methodContents()).__eq(self._contents()))._not();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"hasModification",{},globals.HLNavigationCodeWidget)})},
+args: [],
+source: "hasModification\x0a\x09^ (self methodContents = self contents) not",
+messageSends: ["not", "=", "methodContents", "contents"],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodContents",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@methodContents"];
+if(($receiver = $2) == null || $receiver.isNil){
+$1="";
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"methodContents",{},globals.HLNavigationCodeWidget)})},
+args: [],
+source: "methodContents\x0a\x09^ methodContents ifNil: [ '' ]",
+messageSends: ["ifNil:"],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "methodContents:",
+protocol: 'accessing',
+fn: function (aString){
+var self=this;
+var $1;
+self["@methodContents"]=aString;
+$1=self["@methodContents"];
+return $1;
+},
+args: ["aString"],
+source: "methodContents: aString\x0a\x09^ methodContents := aString",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previous",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return self},
+args: [],
+source: "previous\x0a\x09\x22for browser lists widget\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "previous:",
+protocol: 'accessing',
+fn: function (aWidget){
+var self=this;
+return self},
+args: ["aWidget"],
+source: "previous: aWidget\x0a\x09\x22for browser lists widget\x22",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aBrowserModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._browserModel_(aBrowserModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aBrowserModel:aBrowserModel},globals.HLNavigationCodeWidget.klass)})},
+args: ["aBrowserModel"],
+source: "on: aBrowserModel\x0a\x09^ self new\x0a\x09\x09browserModel: aBrowserModel;\x0a\x09\x09yourself",
+messageSends: ["browserModel:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLNavigationCodeWidget.klass);
+
+
+smalltalk.addClass('HLBrowserCodeWidget', globals.HLNavigationCodeWidget, ['browserModel'], 'Helios-Workspace');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "browserModel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+var $1;
+$1=self["@browserModel"];
+return $1;
+},
+args: [],
+source: "browserModel\x0a\x09^ browserModel",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "browserModel:",
+protocol: 'accessing',
+fn: function (aBrowserModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+self["@browserModel"]=aBrowserModel;
+self._observeSystem();
+$1=self._observeBrowserModel();
+return self}, function($ctx1) {$ctx1.fill(self,"browserModel:",{aBrowserModel:aBrowserModel},globals.HLBrowserCodeWidget)})},
+args: ["aBrowserModel"],
+source: "browserModel: aBrowserModel\x0a\x09browserModel := aBrowserModel.\x0a\x09self \x0a\x09\x09observeSystem;\x0a\x09\x09observeBrowserModel",
+messageSends: ["observeSystem", "observeBrowserModel"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeBrowserModel",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $HLSaveSourceCode(){return globals.HLSaveSourceCode||(typeof HLSaveSourceCode=="undefined"?nil:HLSaveSourceCode)}
+function $HLShowInstanceToggled(){return globals.HLShowInstanceToggled||(typeof HLShowInstanceToggled=="undefined"?nil:HLShowInstanceToggled)}
+function $HLSourceCodeSaved(){return globals.HLSourceCodeSaved||(typeof HLSourceCodeSaved=="undefined"?nil:HLSourceCodeSaved)}
+function $HLAboutToChange(){return globals.HLAboutToChange||(typeof HLAboutToChange=="undefined"?nil:HLAboutToChange)}
+function $HLParseErrorRaised(){return globals.HLParseErrorRaised||(typeof HLParseErrorRaised=="undefined"?nil:HLParseErrorRaised)}
+function $HLCompileErrorRaised(){return globals.HLCompileErrorRaised||(typeof HLCompileErrorRaised=="undefined"?nil:HLCompileErrorRaised)}
+function $HLUnknownVariableErrorRaised(){return globals.HLUnknownVariableErrorRaised||(typeof HLUnknownVariableErrorRaised=="undefined"?nil:HLUnknownVariableErrorRaised)}
+function $HLInstVarAdded(){return globals.HLInstVarAdded||(typeof HLInstVarAdded=="undefined"?nil:HLInstVarAdded)}
+function $HLMethodSelected(){return globals.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+function $HLProtocolSelected(){return globals.HLProtocolSelected||(typeof HLProtocolSelected=="undefined"?nil:HLProtocolSelected)}
+function $HLSourceCodeFocusRequested(){return globals.HLSourceCodeFocusRequested||(typeof HLSourceCodeFocusRequested=="undefined"?nil:HLSourceCodeFocusRequested)}
+function $HLShowTemplate(){return globals.HLShowTemplate||(typeof HLShowTemplate=="undefined"?nil:HLShowTemplate)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(self._browserModel())._announcer();
+_st($1)._on_send_to_($HLSaveSourceCode(),"onSaveIt",self);
+$ctx1.sendIdx["on:send:to:"]=1;
+_st($1)._on_send_to_($HLShowInstanceToggled(),"onShowInstanceToggled",self);
+$ctx1.sendIdx["on:send:to:"]=2;
+_st($1)._on_send_to_($HLSourceCodeSaved(),"onSourceCodeSaved",self);
+$ctx1.sendIdx["on:send:to:"]=3;
+_st($1)._on_send_to_($HLAboutToChange(),"onBrowserAboutToChange:",self);
+$ctx1.sendIdx["on:send:to:"]=4;
+_st($1)._on_send_to_($HLParseErrorRaised(),"onParseError:",self);
+$ctx1.sendIdx["on:send:to:"]=5;
+_st($1)._on_send_to_($HLCompileErrorRaised(),"onCompileError:",self);
+$ctx1.sendIdx["on:send:to:"]=6;
+_st($1)._on_send_to_($HLUnknownVariableErrorRaised(),"onUnknownVariableError:",self);
+$ctx1.sendIdx["on:send:to:"]=7;
+_st($1)._on_send_to_($HLInstVarAdded(),"onInstVarAdded",self);
+$ctx1.sendIdx["on:send:to:"]=8;
+_st($1)._on_send_to_($HLMethodSelected(),"onMethodSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=9;
+_st($1)._on_send_to_($HLClassSelected(),"onClassSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=10;
+_st($1)._on_send_to_($HLPackageSelected(),"onPackageSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=11;
+_st($1)._on_send_to_($HLProtocolSelected(),"onProtocolSelected:",self);
+$ctx1.sendIdx["on:send:to:"]=12;
+_st($1)._on_send_to_($HLSourceCodeFocusRequested(),"onSourceCodeFocusRequested",self);
+$ctx1.sendIdx["on:send:to:"]=13;
+$2=_st($1)._on_send_to_($HLShowTemplate(),"onShowTemplate:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeBrowserModel",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "observeBrowserModel\x0a\x09self browserModel announcer\x0a\x09\x09on: HLSaveSourceCode\x0a\x09\x09send: #onSaveIt\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLShowInstanceToggled\x0a\x09\x09send: #onShowInstanceToggled\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLSourceCodeSaved\x0a\x09\x09send: #onSourceCodeSaved\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLAboutToChange\x0a\x09\x09send: #onBrowserAboutToChange:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLParseErrorRaised\x0a\x09\x09send: #onParseError:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLCompileErrorRaised\x0a\x09\x09send: #onCompileError:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLUnknownVariableErrorRaised\x0a\x09\x09send: #onUnknownVariableError:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLInstVarAdded \x0a\x09\x09send: #onInstVarAdded\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLMethodSelected \x0a\x09\x09send: #onMethodSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a    \x09on: HLClassSelected \x0a\x09\x09send: #onClassSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLPackageSelected \x0a\x09\x09send: #onPackageSelected:\x0a\x09\x09to: self;\x0a\x09\x09\x0a    \x09on: HLProtocolSelected \x0a\x09\x09send: #onProtocolSelected: \x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLSourceCodeFocusRequested \x0a\x09\x09send: #onSourceCodeFocusRequested\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: HLShowTemplate\x0a\x09\x09send: #onShowTemplate:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "announcer", "browserModel"],
+referencedClasses: ["HLSaveSourceCode", "HLShowInstanceToggled", "HLSourceCodeSaved", "HLAboutToChange", "HLParseErrorRaised", "HLCompileErrorRaised", "HLUnknownVariableErrorRaised", "HLInstVarAdded", "HLMethodSelected", "HLClassSelected", "HLPackageSelected", "HLProtocolSelected", "HLSourceCodeFocusRequested", "HLShowTemplate"]
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "observeSystem",
+protocol: 'actions',
+fn: function (){
+var self=this;
+function $MethodModified(){return globals.MethodModified||(typeof MethodModified=="undefined"?nil:MethodModified)}
+return smalltalk.withContext(function($ctx1) { 
+_st(_st(self._browserModel())._systemAnnouncer())._on_send_to_($MethodModified(),"onMethodModified:",self);
+return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "observeSystem\x0a\x09self browserModel systemAnnouncer\x0a    \x09on: MethodModified\x0a        send: #onMethodModified:\x0a\x09\x09to: self",
+messageSends: ["on:send:to:", "systemAnnouncer", "browserModel"],
+referencedClasses: ["MethodModified"]
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onBrowserAboutToChange:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var block;
+function $HLChangeForbidden(){return globals.HLChangeForbidden||(typeof HLChangeForbidden=="undefined"?nil:HLChangeForbidden)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+block=_st(anAnnouncement)._actionBlock();
+$1=self._hasModification();
+if(smalltalk.assert($1)){
+self._confirm_ifTrue_("Changes have not been saved. Do you want to discard these changes?",(function(){
+return smalltalk.withContext(function($ctx2) {
+self._methodContents_(self._contents());
+return _st(block)._value();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+_st($HLChangeForbidden())._signal();
+};
+return self}, function($ctx1) {$ctx1.fill(self,"onBrowserAboutToChange:",{anAnnouncement:anAnnouncement,block:block},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onBrowserAboutToChange: anAnnouncement\x0a\x09| block |\x0a\x09\x0a\x09block := anAnnouncement actionBlock.\x0a\x09\x0a\x09self hasModification\x0a\x09\x09ifTrue: [\x0a\x09\x09\x09self \x0a\x09\x09\x09\x09confirm: 'Changes have not been saved. Do you want to discard these changes?' \x0a\x09\x09\x09\x09ifTrue: [\x0a\x09\x09\x09\x09\x09\x22Don't ask twice\x22\x0a\x09\x09\x09\x09\x09self methodContents: self contents.\x0a\x09\x09\x09\x09\x09block value ].\x0a\x09\x09\x09\x0a\x09\x09\x09\x0a\x09\x09\x09HLChangeForbidden signal ]",
+messageSends: ["actionBlock", "ifTrue:", "hasModification", "confirm:ifTrue:", "methodContents:", "contents", "value", "signal"],
+referencedClasses: ["HLChangeForbidden"]
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onClassSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var class_;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+class_=_st(anAnnouncement)._item();
+$1=class_;
+if(($receiver = $1) == null || $receiver.isNil){
+$2=self._contents_("");
+$ctx1.sendIdx["contents:"]=1;
+return $2;
+} else {
+$1;
+};
+self._contents_(_st(class_)._definition());
+return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement,class_:class_},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onClassSelected: anAnnouncement\x0a\x09| class |\x0a\x09\x0a\x09class:= anAnnouncement item.\x0a\x09\x0a\x09class ifNil: [ ^ self contents: '' ].\x0a\x09self contents: class definition",
+messageSends: ["item", "ifNil:", "contents:", "definition"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onCompileError:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._alert_(_st(_st(anAnnouncement)._error())._messageText());
+return self}, function($ctx1) {$ctx1.fill(self,"onCompileError:",{anAnnouncement:anAnnouncement},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onCompileError: anAnnouncement\x0a\x09self alert: anAnnouncement error messageText",
+messageSends: ["alert:", "messageText", "error"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onInstVarAdded",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._browserModel())._save_(self._contents());
+return self}, function($ctx1) {$ctx1.fill(self,"onInstVarAdded",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "onInstVarAdded\x0a\x09self browserModel save: self contents",
+messageSends: ["save:", "browserModel", "contents"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodModified:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var method;
+return smalltalk.withContext(function($ctx1) { 
+var $3,$2,$1,$5,$4,$7,$6,$receiver;
+method=_st(anAnnouncement)._method();
+$3=self._browserModel();
+$ctx1.sendIdx["browserModel"]=1;
+$2=_st($3)._selectedClass();
+$1=_st($2).__eq(_st(method)._methodClass());
+$ctx1.sendIdx["="]=1;
+if(! smalltalk.assert($1)){
+return self;
+};
+$5=self._browserModel();
+$ctx1.sendIdx["browserModel"]=2;
+$4=_st($5)._selectedMethod();
+$ctx1.sendIdx["selectedMethod"]=1;
+if(($receiver = $4) == null || $receiver.isNil){
+return self;
+} else {
+$4;
+};
+$7=_st(_st(self._browserModel())._selectedMethod())._selector();
+$ctx1.sendIdx["selector"]=1;
+$6=_st($7).__eq(_st(method)._selector());
+if(! smalltalk.assert($6)){
+return self;
+};
+self._refresh();
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodModified:",{anAnnouncement:anAnnouncement,method:method},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onMethodModified: anAnnouncement\x0a\x09| method |\x0a\x09\x0a\x09method := anAnnouncement method.\x0a\x09\x0a\x09self browserModel selectedClass = method methodClass ifFalse: [ ^ self ].\x0a\x09self browserModel selectedMethod ifNil: [ ^ self ].\x0a\x09self browserModel selectedMethod selector = method selector ifFalse: [ ^ self ].\x0a\x0a\x09self refresh",
+messageSends: ["method", "ifFalse:", "=", "selectedClass", "browserModel", "methodClass", "ifNil:", "selectedMethod", "selector", "refresh"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onMethodSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var method;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+method=_st(anAnnouncement)._item();
+$1=method;
+if(($receiver = $1) == null || $receiver.isNil){
+$2=self._contents_("");
+$ctx1.sendIdx["contents:"]=1;
+return $2;
+} else {
+$1;
+};
+self._contents_(_st(method)._source());
+return self}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{anAnnouncement:anAnnouncement,method:method},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onMethodSelected: anAnnouncement\x0a\x09| method |\x0a\x09\x0a\x09method := anAnnouncement item.\x0a\x09\x0a\x09method ifNil: [ ^ self contents: '' ].\x0a\x09self contents: method source",
+messageSends: ["item", "ifNil:", "contents:", "source"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onPackageSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var package_;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$receiver;
+package_=_st(anAnnouncement)._item();
+$1=package_;
+if(($receiver = $1) == null || $receiver.isNil){
+$2=self._contents_("");
+$ctx1.sendIdx["contents:"]=1;
+return $2;
+} else {
+$1;
+};
+self._contents_(_st(package_)._definition());
+return self}, function($ctx1) {$ctx1.fill(self,"onPackageSelected:",{anAnnouncement:anAnnouncement,package_:package_},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onPackageSelected: anAnnouncement\x0a\x09| package |\x0a\x09\x0a\x09package := anAnnouncement item.\x0a\x09\x0a\x09package ifNil: [ ^ self contents: '' ].\x0a\x09self contents: package definition",
+messageSends: ["item", "ifNil:", "contents:", "definition"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onParseError:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var lineIndex,newContents;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$2,$6,$5,$4;
+lineIndex=(1);
+self._contents_(_st($String())._streamContents_((function(stream){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._contents())._linesDo_((function(each){
+return smalltalk.withContext(function($ctx3) {
+$1=_st(lineIndex).__eq(_st(anAnnouncement)._line());
+if(smalltalk.assert($1)){
+$3=_st(anAnnouncement)._column();
+$ctx3.sendIdx["column"]=1;
+$2=_st(each)._copyFrom_to_((1),$3);
+$ctx3.sendIdx["copyFrom:to:"]=1;
+_st(stream)._nextPutAll_($2);
+$ctx3.sendIdx["nextPutAll:"]=1;
+_st(stream)._nextPutAll_("<- ");
+$ctx3.sendIdx["nextPutAll:"]=2;
+_st(stream)._nextPutAll_(_st(anAnnouncement)._message());
+$ctx3.sendIdx["nextPutAll:"]=3;
+_st(stream)._nextPutAll_(" ");
+$ctx3.sendIdx["nextPutAll:"]=4;
+$6=_st(_st(anAnnouncement)._column()).__plus((1));
+$ctx3.sendIdx["+"]=1;
+$5=_st(each)._copyFrom_to_($6,_st(each)._size());
+$4=_st(stream)._nextPutAll_($5);
+$ctx3.sendIdx["nextPutAll:"]=5;
+$4;
+} else {
+_st(stream)._nextPutAll_(each);
+$ctx3.sendIdx["nextPutAll:"]=6;
+};
+_st(stream)._nextPutAll_(_st($String())._cr());
+lineIndex=_st(lineIndex).__plus((1));
+return lineIndex;
+}, function($ctx3) {$ctx3.fillBlock({each:each},$ctx2,2)})}));
+}, function($ctx2) {$ctx2.fillBlock({stream:stream},$ctx1,1)})})));
+return self}, function($ctx1) {$ctx1.fill(self,"onParseError:",{anAnnouncement:anAnnouncement,lineIndex:lineIndex,newContents:newContents},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onParseError: anAnnouncement\x0a\x09| lineIndex newContents |\x0a\x09\x0a\x09lineIndex := 1.\x0a\x09\x0a\x09self contents: (String streamContents: [ :stream |\x0a\x09\x09self contents linesDo: [ :each |\x0a\x09\x09\x09lineIndex = anAnnouncement line \x0a\x09\x09\x09\x09ifTrue: [ \x0a\x09\x09\x09\x09\x09stream \x0a\x09\x09\x09\x09\x09\x09nextPutAll: (each copyFrom: 1 to: anAnnouncement column);\x0a\x09\x09\x09\x09\x09\x09nextPutAll: '<- ';\x0a\x09\x09\x09\x09\x09\x09nextPutAll: anAnnouncement message;\x0a\x09\x09\x09\x09\x09\x09nextPutAll: ' ';\x0a\x09\x09\x09\x09\x09\x09nextPutAll: (each copyFrom: anAnnouncement column + 1 to: each size) ]\x0a\x09\x09\x09\x09ifFalse: [ stream nextPutAll: each ].\x0a\x09\x09\x09stream nextPutAll: String cr.\x0a\x09\x09\x09lineIndex := lineIndex + 1 ] ])",
+messageSends: ["contents:", "streamContents:", "linesDo:", "contents", "ifTrue:ifFalse:", "=", "line", "nextPutAll:", "copyFrom:to:", "column", "message", "+", "size", "cr"],
+referencedClasses: ["String"]
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onProtocolSelected:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$receiver;
+$2=self._browserModel();
+$ctx1.sendIdx["browserModel"]=1;
+$1=_st($2)._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$3=self._contents_("");
+$ctx1.sendIdx["contents:"]=1;
+return $3;
+} else {
+$1;
+};
+self._contents_(_st(_st(self._browserModel())._selectedClass())._definition());
+return self}, function($ctx1) {$ctx1.fill(self,"onProtocolSelected:",{anAnnouncement:anAnnouncement},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onProtocolSelected: anAnnouncement\x0a\x09self browserModel selectedClass ifNil: [ ^ self contents: '' ].\x0a\x09self contents: self browserModel selectedClass definition",
+messageSends: ["ifNil:", "selectedClass", "browserModel", "contents:", "definition"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSaveIt",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._browserModel())._save_(self._contents());
+return self}, function($ctx1) {$ctx1.fill(self,"onSaveIt",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "onSaveIt\x0a\x09self browserModel save: self contents",
+messageSends: ["save:", "browserModel", "contents"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowInstanceToggled",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$receiver;
+$2=self._browserModel();
+$ctx1.sendIdx["browserModel"]=1;
+$1=_st($2)._selectedClass();
+$ctx1.sendIdx["selectedClass"]=1;
+if(($receiver = $1) == null || $receiver.isNil){
+$3=self._contents_("");
+$ctx1.sendIdx["contents:"]=1;
+return $3;
+} else {
+$1;
+};
+self._contents_(_st(_st(self._browserModel())._selectedClass())._definition());
+return self}, function($ctx1) {$ctx1.fill(self,"onShowInstanceToggled",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "onShowInstanceToggled\x0a\x09self browserModel selectedClass ifNil: [ ^ self contents: '' ].\x0a    \x0a\x09self contents: self browserModel selectedClass definition",
+messageSends: ["ifNil:", "selectedClass", "browserModel", "contents:", "definition"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onShowTemplate:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._contents_(_st(anAnnouncement)._template());
+return self}, function($ctx1) {$ctx1.fill(self,"onShowTemplate:",{anAnnouncement:anAnnouncement},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onShowTemplate: anAnnouncement\x0a\x09self contents: anAnnouncement template",
+messageSends: ["contents:", "template"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSourceCodeFocusRequested",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._focus();
+return self}, function($ctx1) {$ctx1.fill(self,"onSourceCodeFocusRequested",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "onSourceCodeFocusRequested\x0a\x09self focus",
+messageSends: ["focus"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onSourceCodeSaved",
+protocol: 'reactions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self._methodContents_(self._contents());
+self._updateState();
+return self}, function($ctx1) {$ctx1.fill(self,"onSourceCodeSaved",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "onSourceCodeSaved\x0a\x09self methodContents: self contents.\x0a\x09self updateState",
+messageSends: ["methodContents:", "contents", "updateState"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "onUnknownVariableError:",
+protocol: 'reactions',
+fn: function (anAnnouncement){
+var self=this;
+var error;
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+error=_st(anAnnouncement)._error();
+self._confirm_ifTrue_(_st($String())._streamContents_((function(stream){
+return smalltalk.withContext(function($ctx2) {
+_st(stream)._nextPutAll_(_st(error)._messageText());
+$ctx2.sendIdx["nextPutAll:"]=1;
+_st(stream)._nextPutAll_(_st($String())._cr());
+$ctx2.sendIdx["nextPutAll:"]=2;
+$1=_st(stream)._nextPutAll_("Would you like to define an instance variable?");
+return $1;
+}, function($ctx2) {$ctx2.fillBlock({stream:stream},$ctx1,1)})})),(function(){
+return smalltalk.withContext(function($ctx2) {
+return _st(self._browserModel())._addInstVarNamed_(_st(error)._variableName());
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"onUnknownVariableError:",{anAnnouncement:anAnnouncement,error:error},globals.HLBrowserCodeWidget)})},
+args: ["anAnnouncement"],
+source: "onUnknownVariableError: anAnnouncement\x0a\x09| error |\x0a\x09\x0a\x09error := anAnnouncement error.\x0a\x09\x0a\x09self \x0a\x09\x09confirm: (String streamContents: [ :stream |\x0a\x09\x09\x09stream \x0a\x09\x09\x09\x09nextPutAll: error messageText;\x0a\x09\x09\x09\x09nextPutAll: String cr;\x0a\x09\x09\x09\x09nextPutAll: 'Would you like to define an instance variable?' ])\x0a\x09\x09ifTrue: [\x0a\x09\x09\x09self browserModel addInstVarNamed: error variableName ]",
+messageSends: ["error", "confirm:ifTrue:", "streamContents:", "nextPutAll:", "messageText", "cr", "addInstVarNamed:", "browserModel", "variableName"],
+referencedClasses: ["String"]
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "refresh",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self._hasModification();
+if(smalltalk.assert($1)){
+return self;
+};
+$2=self._hasFocus();
+if(smalltalk.assert($2)){
+return self;
+};
+self._contents_(_st(_st(self._browserModel())._selectedMethod())._source());
+return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "refresh\x0a\x09self hasModification ifTrue: [ ^ self ].\x0a    self hasFocus ifTrue: [ ^ self ].\x0a\x0a\x09self contents: self browserModel selectedMethod source",
+messageSends: ["ifTrue:", "hasModification", "hasFocus", "contents:", "source", "selectedMethod", "browserModel"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderButtonsOn:",
+protocol: 'actions',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=_st(html)._button();
+_st($1)._class_("button");
+_st($1)._with_("SaveIt");
+$2=_st($1)._onClick_((function(){
+return smalltalk.withContext(function($ctx2) {
+return self._saveIt();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+($ctx1.supercall = true, globals.HLBrowserCodeWidget.superclass.fn.prototype._renderButtonsOn_.apply(_st(self), [html]));
+$ctx1.supercall = false;
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},globals.HLBrowserCodeWidget)})},
+args: ["html"],
+source: "renderButtonsOn: html\x0a\x09html button \x0a\x09\x09class: 'button';\x0a\x09\x09with: 'SaveIt';\x0a\x09\x09onClick: [ self saveIt ].\x0a\x09super renderButtonsOn: html",
+messageSends: ["class:", "button", "with:", "onClick:", "saveIt", "renderButtonsOn:"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "saveIt",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._browserModel())._saveSourceCode();
+return self}, function($ctx1) {$ctx1.fill(self,"saveIt",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "saveIt\x0a\x09self browserModel saveSourceCode",
+messageSends: ["saveSourceCode", "browserModel"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+($ctx1.supercall = true, globals.HLBrowserCodeWidget.superclass.fn.prototype._unregsiter.apply(_st(self), []));
+$ctx1.supercall = false;
+$2=self._browserModel();
+$ctx1.sendIdx["browserModel"]=1;
+$1=_st($2)._announcer();
+_st($1)._unsubscribe_(self);
+$ctx1.sendIdx["unsubscribe:"]=1;
+_st(_st(self._browserModel())._systemAnnouncer())._unsubscribe_(self);
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLBrowserCodeWidget)})},
+args: [],
+source: "unregister\x0a\x09super unregsiter.\x0a\x09\x0a\x09self browserModel announcer unsubscribe: self.\x0a\x09self browserModel systemAnnouncer unsubscribe: self",
+messageSends: ["unregsiter", "unsubscribe:", "announcer", "browserModel", "systemAnnouncer"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return false;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ false",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "on:",
+protocol: 'instance creation',
+fn: function (aBrowserModel){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=self._new();
+_st($2)._browserModel_(aBrowserModel);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"on:",{aBrowserModel:aBrowserModel},globals.HLBrowserCodeWidget.klass)})},
+args: ["aBrowserModel"],
+source: "on: aBrowserModel\x0a\x09^ self new\x0a\x09\x09browserModel: aBrowserModel;\x0a\x09\x09yourself",
+messageSends: ["browserModel:", "new", "yourself"],
+referencedClasses: []
+}),
+globals.HLBrowserCodeWidget.klass);
+
+
+smalltalk.addClass('HLWorkspace', globals.HLWidget, ['codeWidget', 'transcript'], 'Helios-Workspace');
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canHaveFocus",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canHaveFocus\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWorkspace);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "codeWidget",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLCodeWidget(){return globals.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@codeWidget"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@codeWidget"]=_st($HLCodeWidget())._new();
+$1=self["@codeWidget"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"codeWidget",{},globals.HLWorkspace)})},
+args: [],
+source: "codeWidget\x0a\x09^ codeWidget ifNil: [ codeWidget := HLCodeWidget new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HLCodeWidget"]
+}),
+globals.HLWorkspace);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "focus",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._codeWidget())._focus();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLWorkspace)})},
+args: [],
+source: "focus\x0a\x09^ self codeWidget focus",
+messageSends: ["focus", "codeWidget"],
+referencedClasses: []
+}),
+globals.HLWorkspace);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderContentOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+return smalltalk.withContext(function($ctx1) { 
+_st(html)._with_(_st($HLContainer())._with_(_st($HLHorizontalSplitter())._with_with_(self._codeWidget(),(function(canvas){
+return smalltalk.withContext(function($ctx2) {
+return self._renderTranscriptOn_(canvas);
+}, function($ctx2) {$ctx2.fillBlock({canvas:canvas},$ctx1,1)})}))));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLWorkspace)})},
+args: ["html"],
+source: "renderContentOn: html\x0a\x09html with: (HLContainer with: (HLHorizontalSplitter\x0a\x09\x09with: self codeWidget\x0a\x09\x09with: [ :canvas | self renderTranscriptOn: canvas ]))",
+messageSends: ["with:", "with:with:", "codeWidget", "renderTranscriptOn:"],
+referencedClasses: ["HLContainer", "HLHorizontalSplitter"]
+}),
+globals.HLWorkspace);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "renderTranscriptOn:",
+protocol: 'rendering',
+fn: function (html){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$3,$4,$2;
+$1=_st(html)._div();
+$ctx1.sendIdx["div"]=1;
+_st($1)._class_("transcript-container");
+$ctx1.sendIdx["class:"]=1;
+$2=_st($1)._with_((function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(html)._div();
+_st($3)._class_("list-label");
+$4=_st($3)._with_("Transcript");
+$4;
+return _st(self._transcript())._renderOn_(html);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+$ctx1.sendIdx["with:"]=1;
+return self}, function($ctx1) {$ctx1.fill(self,"renderTranscriptOn:",{html:html},globals.HLWorkspace)})},
+args: ["html"],
+source: "renderTranscriptOn: html\x0a\x09html div \x0a\x09\x09class: 'transcript-container';\x0a\x09\x09with: [\x0a\x09\x09\x09html div\x0a\x09\x09\x09\x09class: 'list-label';\x0a\x09\x09\x09\x09with: 'Transcript'.\x0a\x09\x09\x09self transcript renderOn: html ]",
+messageSends: ["class:", "div", "with:", "renderOn:", "transcript"],
+referencedClasses: []
+}),
+globals.HLWorkspace);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "transcript",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+function $HLTranscript(){return globals.HLTranscript||(typeof HLTranscript=="undefined"?nil:HLTranscript)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$receiver;
+$2=self["@transcript"];
+if(($receiver = $2) == null || $receiver.isNil){
+self["@transcript"]=_st($HLTranscript())._new();
+$1=self["@transcript"];
+} else {
+$1=$2;
+};
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"transcript",{},globals.HLWorkspace)})},
+args: [],
+source: "transcript\x0a\x09^ transcript ifNil: [ transcript := HLTranscript new ]",
+messageSends: ["ifNil:", "new"],
+referencedClasses: ["HLTranscript"]
+}),
+globals.HLWorkspace);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "unregister",
+protocol: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLWorkspace.superclass.fn.prototype._unregister.apply(_st(self), []));
+$ctx1.supercall = false;
+$ctx1.sendIdx["unregister"]=1;
+_st(self._transcript())._unregister();
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLWorkspace)})},
+args: [],
+source: "unregister\x0a\x09super unregister.\x0a\x09self transcript unregister",
+messageSends: ["unregister", "transcript"],
+referencedClasses: []
+}),
+globals.HLWorkspace);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "canBeOpenAsTab",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "canBeOpenAsTab\x0a\x09^ true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWorkspace.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabClass",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "workspace";
+},
+args: [],
+source: "tabClass\x0a\x09^ 'workspace'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWorkspace.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabLabel",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Workspace";
+},
+args: [],
+source: "tabLabel\x0a\x09^ 'Workspace'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWorkspace.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "tabPriority",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return (10);
+},
+args: [],
+source: "tabPriority\x0a\x09^ 10",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLWorkspace.klass);
+
+});

src/Helios-Workspace.st

@@ -0,0 +1,863 @@
+Smalltalk createPackage: 'Helios-Workspace'!
+Object subclass: #HLCodeModel
+	instanceVariableNames: 'announcer environment receiver'
+	package: 'Helios-Workspace'!
+
+!HLCodeModel methodsFor: 'accessing'!
+
+announcer
+	^ announcer ifNil: [ announcer := Announcer new ]
+!
+
+environment
+	^ environment ifNil: [ HLManager current environment ]
+!
+
+environment: anEnvironment
+	environment := anEnvironment
+!
+
+receiver
+	^ receiver ifNil: [ receiver := self defaultReceiver ]
+!
+
+receiver: anObject
+	receiver := anObject
+! !
+
+!HLCodeModel methodsFor: 'actions'!
+
+browse: anObject
+	anObject browse
+!
+
+doIt: aString
+	"Evaluate aString in the receiver's `environment`.
+	
+	Note: Catch any error and handle it manually, bypassing
+	boot.js behavior to avoid the browser default action on
+	ctrl+d/ctrl+p.
+	
+	See https://github.com/amber-smalltalk/amber/issues/882"
+
+	^ [ self environment evaluate: aString for: self receiver ]
+		tryCatch: [ :e | 
+			ErrorHandler handleError: e.
+			nil ]
+!
+
+inspect: anObject
+	self environment inspect: anObject
+! !
+
+!HLCodeModel methodsFor: 'defaults'!
+
+defaultReceiver
+	^ self environment doItReceiver
+! !
+
+!HLCodeModel class methodsFor: 'actions'!
+
+on: anEnvironment
+
+	^ self new
+    	environment: anEnvironment;
+        yourself
+! !
+
+HLWidget subclass: #HLCodeWidget
+	instanceVariableNames: 'model wrapper code editor state'
+	package: 'Helios-Workspace'!
+
+!HLCodeWidget methodsFor: 'accessing'!
+
+announcer
+	^ self model announcer
+!
+
+contents
+	^ editor getValue
+!
+
+contents: aString
+	editor setValue: aString.
+	state ifNotNil: [ self updateState ]
+!
+
+currentLine
+    ^editor getLine: (editor getCursor line)
+!
+
+currentLineOrSelection
+    ^editor somethingSelected
+		ifFalse: [ self currentLine ]
+		ifTrue: [ self selection ]
+!
+
+editorOptions
+	^ #{
+		'theme' -> ('helios.editorTheme' settingValueIfAbsent: 'default').
+		'mode' -> 'text/x-stsrc'.
+        'lineNumbers' -> true.
+        'enterMode' -> 'flat'.
+        'indentWithTabs' -> true.
+		'indentUnit' -> 4.
+        'matchBrackets' -> true.
+        'electricChars' -> false.
+		'keyMap' -> 'Amber'.
+		'extraKeys' -> (HashedCollection with: ('helios.completionKey' settingValueIfAbsent: 'Shift-Space') -> 'autocomplete')
+	}
+!
+
+model
+	^ model ifNil: [ model := HLCodeModel new ]
+!
+
+model: aModel
+	model := aModel
+!
+
+receiver
+	^ self model receiver
+!
+
+receiver: anObject
+	self model receiver: anObject
+!
+
+selection
+	^editor getSelection
+!
+
+selectionEnd
+   ^code element selectionEnd
+!
+
+selectionEnd: anInteger
+   code element selectionEnd: anInteger
+!
+
+selectionStart
+   ^code element selectionStart
+!
+
+selectionStart: anInteger
+   code element selectionStart: anInteger
+! !
+
+!HLCodeWidget methodsFor: 'actions'!
+
+browseIt
+	| result |
+	
+	result := [ self doIt ] on: Error do: [ :exception | 
+		^ ErrorHandler handleError: exception ].
+		
+	self model browse: result
+!
+
+clear
+	self contents: ''
+!
+
+configureEditor
+	self editor at: 'amberCodeWidget' put: self.
+	self editor on: 'change' do: [ self onChange ].
+
+	self wrapper asJQuery on: 'mousedown' in: '.CodeMirror pre' do: [ :event | | position node |
+		(event at: 'ctrlKey') ifTrue: [
+			position := self editor coordsChar: #{ 
+				'left' -> event clientX.
+				'top' -> event clientY
+			}.
+			self onCtrlClickAt: (position line @ position ch) + 1.
+			event preventDefault ] ]
+!
+
+doIt
+	| result |
+
+	result := self model doIt: self currentLineOrSelection.
+	self model announcer announce: (HLDoItExecuted on: model).
+
+	^ result
+!
+
+editor
+	^ editor
+!
+
+focus
+	editor focus
+!
+
+inspectIt
+	self model inspect: self doIt
+!
+
+navigateTo: aString
+	Finder findString: aString
+!
+
+navigateToReference: aString
+	(HLReferences openAsTab)
+		search: aString
+!
+
+print: aString
+	| start stop currentLine |
+    currentLine := (editor getCursor: false) line.
+	start := HashedCollection new.
+	start at: 'line' put: currentLine.
+	start at: 'ch' put: (editor getCursor: false) ch.
+    (editor getSelection) ifEmpty: [
+    	"select current line if selection is empty"
+    	start at: 'ch' put: (editor getLine: currentLine) size.
+        editor setSelection: #{'line' -> currentLine. 'ch' -> 0} end: start.
+    ].
+	stop := HashedCollection new.
+	stop at: 'line' put: currentLine.
+	stop at: 'ch' put: ((start at: 'ch') + aString size + 2).
+
+	editor replaceSelection: (editor getSelection, ' ', aString, ' ').
+	editor setCursor: (editor getCursor: true).
+	editor setSelection: stop end: start
+!
+
+printIt
+	self print: self doIt printString
+!
+
+saveIt
+	"I do not do anything"
+!
+
+setEditorOn: aTextarea
+	<self['@editor'] = CodeMirror.fromTextArea(aTextarea, self._editorOptions())>
+! !
+
+!HLCodeWidget methodsFor: 'hints'!
+
+messageHintFor: anEditor token: aToken
+	^ (Smalltalk vm allSelectors asArray 
+		select: [ :each | each includesSubString: aToken string ])
+		reject: [ :each | each = aToken string ]
+!
+
+variableHintFor: anEditor token: aToken
+	| variables classNames pseudoVariables |
+	
+	variables := (anEditor display wrapper asJQuery find: 'span.cm-variable') get
+		collect: [ :each | each asJQuery html ].
+	
+	classNames := Smalltalk classes collect: [ :each | each name ].
+	pseudoVariables := Smalltalk pseudoVariableNames.
+	
+	^ ((variables, classNames, pseudoVariables) asSet asArray sort
+		select: [ :each | each includesSubString: aToken string ])
+		reject: [ :each | each = aToken string ]
+! !
+
+!HLCodeWidget methodsFor: 'reactions'!
+
+onChange
+	self updateState
+!
+
+onCtrlClickAt: aPoint
+	| ast node |
+	
+	ast := [ Smalltalk parse: self editor getValue ] 
+		on: Error 
+		do: [ :error | ^ self ].
+	
+	node := ast 
+		navigationNodeAt: aPoint 
+		ifAbsent: [ ^ nil ].
+		
+	self navigateTo: node navigationLink
+!
+
+onInspectIt
+
+	self inspectIt
+!
+
+onPrintIt
+
+	self printIt
+!
+
+onSaveIt
+	"I do not do anything"
+! !
+
+!HLCodeWidget methodsFor: 'rendering'!
+
+renderButtonsOn: html
+	html button 
+		class: 'button';
+		with: 'DoIt';
+		onClick: [ self doIt ].
+	html button 
+		class: 'button';
+		with: 'PrintIt';
+		onClick: [ self printIt ].
+	html button 
+		class: 'button';
+		with: 'InspectIt';
+		onClick: [ self inspectIt ].
+	html button 
+		class: 'button';
+		with: 'BrowseIt';
+		onClick: [ self browseIt ]
+!
+
+renderContentOn: html
+	html div class: 'editor'; with: [
+		code := html textarea ].
+	state := html div class: 'state'.
+	
+	html div 
+		class: 'buttons_bar';
+		with: [ self renderButtonsOn: html ].
+	
+	self 
+		setEditorOn: code element;
+		configureEditor;
+		updateState
+! !
+
+!HLCodeWidget methodsFor: 'testing'!
+
+canHaveFocus
+	^ true
+!
+
+hasFocus
+	^ code asJQuery is: ':active'
+!
+
+hasModification
+	^ false
+! !
+
+!HLCodeWidget methodsFor: 'updating'!
+
+updateState
+	self hasModification 
+		ifTrue: [ state asJQuery addClass: 'modified' ]
+		ifFalse: [ state asJQuery removeClass: 'modified' ]
+! !
+
+!HLCodeWidget class methodsFor: 'accessing'!
+
+keyMap
+	^ HLManager current keyBinder systemIsMac
+		ifTrue: [ self macKeyMap ]
+		ifFalse: [ self pcKeyMap ]
+!
+
+macKeyMap
+	^ #{
+		'Alt-Backspace'			-> 'delWordBefore'.
+		'Alt-Delete'			-> 'delWordAfter'. 
+		'Alt-Left'				-> 'goWordLeft'.
+		'Alt-Right'				-> 'goWordRight'. 
+		'Cmd-A'					-> 'selectAll'. 
+		'Cmd-Alt-F'				-> 'replace'. 
+		'Cmd-D'					-> 'doIt'. 
+		'Cmd-B'					-> 'browseIt'. 
+		'Cmd-Down'				-> 'goDocEnd'. 
+		'Cmd-End'				-> 'goDocEnd'. 
+		'Cmd-F'					-> 'find'.
+		'Cmd-G'					-> 'findNext'. 
+		'Cmd-I'					-> 'inspectIt'. 
+		'Cmd-Left'				-> 'goLineStart'. 
+		'Cmd-P'					-> 'printIt'. 
+		'Cmd-Right'				-> 'goLineEnd'. 
+		'Cmd-S'					-> 'saveIt'. 
+		'Cmd-Up'				-> 'goDocStart'. 
+		'Cmd-Y'					-> 'redo'.
+		'Cmd-Z'					-> 'undo'. 
+		'Cmd-['					-> 'indentLess'. 
+		'Cmd-]'					-> 'indentMore'.
+		'Ctrl-Alt-Backspace'	-> 'delWordAfter'. 
+		'Shift-Cmd-Alt-F'		-> 'replaceAll'.
+		'Shift-Cmd-G'			-> 'findPrev'. 
+		'Shift-Cmd-Z'			-> 'redo'. 
+    	'fallthrough' 			-> { 'basic'. 'emacsy' }
+  }
+!
+
+pcKeyMap
+	^ #{
+		'Alt-Left' -> 		'goLineStart'. 
+		'Alt-Right' -> 		'goLineEnd'.
+		'Alt-Up' -> 		'goDocStart'. 
+		'Ctrl-A' -> 		'selectAll'. 
+		'Ctrl-Backspace' -> 'delWordBefore'. 
+		'Ctrl-D' -> 		'doIt'. 
+		'Ctrl-B' -> 		'browseIt'. 
+		'Ctrl-Delete' -> 		'delWordAfter'. 
+		'Ctrl-Down' -> 		'goDocEnd'.
+		'Ctrl-End' -> 		'goDocEnd'. 
+		'Ctrl-F' -> 		'find'.
+		'Ctrl-G' -> 		'findNext'. 
+		'Ctrl-I' -> 		'inspectIt'.
+		'Ctrl-Home' -> 		'goDocStart'. 
+		'Ctrl-Left' -> 		'goWordLeft'. 
+		'Ctrl-P' -> 		'printIt'.
+		'Ctrl-Right' -> 	'goWordRight'. 
+		'Ctrl-S' -> 		'saveIt'. 
+		'Ctrl-Y' -> 		'redo'.
+		'Ctrl-Z' -> 		'undo'. 
+		'Ctrl-[' -> 		'indentLess'. 
+		'Ctrl-]' -> 		'indentMore'.
+		'Shift-Ctrl-F' -> 	'replace'. 
+		'Shift-Ctrl-G' -> 	'findPrev'. 
+		'Shift-Ctrl-R' -> 	'replaceAll'.
+		'Shift-Ctrl-Z' -> 	'redo'. 
+		'fallthrough' -> 	#('basic')
+}
+! !
+
+!HLCodeWidget class methodsFor: 'hints'!
+
+hintFor: anEditor options: options
+	| cursor token completions |
+	
+	cursor := anEditor getCursor.
+	token := anEditor getTokenAt: cursor.
+	token at: 'state' put: ((CodeMirror basicAt: 'innerMode')
+		value: anEditor getMode value: (token at: 'state')) state.
+	
+	completions := token type = 'variable' 
+		ifTrue: [ HLCodeWidget variableHintFor: anEditor token: token ]
+		ifFalse: [ HLCodeWidget messageHintFor: anEditor token: token ].
+	
+	^ #{
+		'list' -> completions.
+		'from' -> ((CodeMirror basicAt: 'Pos') value: cursor line value: token end).
+		'to' -> ((CodeMirror basicAt: 'Pos') value: cursor line value: token start)
+	}
+!
+
+messageHintFor: anEditor token: aToken
+	^ (anEditor at: 'amberCodeWidget')
+		messageHintFor: anEditor token: aToken
+!
+
+variableHintFor: anEditor token: aToken
+	^ (anEditor at: 'amberCodeWidget')
+		variableHintFor: anEditor token: aToken
+! !
+
+!HLCodeWidget class methodsFor: 'initialization'!
+
+initialize
+	super initialize.
+	self 
+		setupCodeMirror;
+		setupCommands;
+		setupKeyMaps.
+!
+
+setupCodeMirror
+	< 
+		CodeMirror.keyMap.default.fallthrough = ["basic"];
+		CodeMirror.commands.autocomplete = function(cm) {
+			CodeMirror.showHint(cm, self._hintFor_options_);
+		}
+	>
+!
+
+setupCommands
+	(CodeMirror basicAt: 'commands') 
+		at: 'doIt' put: [ :cm | cm amberCodeWidget doIt ];
+		at: 'inspectIt' put: [ :cm | cm amberCodeWidget inspectIt ];
+		at: 'printIt' put: [ :cm | cm amberCodeWidget printIt ];
+		at: 'saveIt' put: [ :cm | cm amberCodeWidget saveIt ];
+		at: 'browseIt' put: [ :cm | cm amberCodeWidget browseIt ]
+!
+
+setupKeyMaps
+	<CodeMirror.keyMap['Amber'] = self._keyMap()>
+! !
+
+HLCodeWidget subclass: #HLNavigationCodeWidget
+	instanceVariableNames: 'methodContents'
+	package: 'Helios-Workspace'!
+
+!HLNavigationCodeWidget methodsFor: 'accessing'!
+
+configureEditor
+	super configureEditor.
+	self contents: self methodContents
+!
+
+contents: aString
+	self methodContents: aString.
+	super contents: aString
+!
+
+methodContents
+	^ methodContents ifNil: [ '' ]
+!
+
+methodContents: aString
+	^ methodContents := aString
+!
+
+previous
+	"for browser lists widget"
+!
+
+previous: aWidget
+	"for browser lists widget"
+! !
+
+!HLNavigationCodeWidget methodsFor: 'testing'!
+
+hasModification
+	^ (self methodContents = self contents) not
+! !
+
+!HLNavigationCodeWidget class methodsFor: 'instance creation'!
+
+on: aBrowserModel
+	^ self new
+		browserModel: aBrowserModel;
+		yourself
+! !
+
+!HLNavigationCodeWidget class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ false
+! !
+
+HLNavigationCodeWidget subclass: #HLBrowserCodeWidget
+	instanceVariableNames: 'browserModel'
+	package: 'Helios-Workspace'!
+
+!HLBrowserCodeWidget methodsFor: 'accessing'!
+
+browserModel
+	^ browserModel
+!
+
+browserModel: aBrowserModel
+	browserModel := aBrowserModel.
+	self 
+		observeSystem;
+		observeBrowserModel
+! !
+
+!HLBrowserCodeWidget methodsFor: 'actions'!
+
+observeBrowserModel
+	self browserModel announcer
+		on: HLSaveSourceCode
+		send: #onSaveIt
+		to: self;
+		
+		on: HLShowInstanceToggled
+		send: #onShowInstanceToggled
+		to: self;
+		
+		on: HLSourceCodeSaved
+		send: #onSourceCodeSaved
+		to: self;
+		
+		on: HLAboutToChange
+		send: #onBrowserAboutToChange:
+		to: self;
+		
+		on: HLParseErrorRaised
+		send: #onParseError:
+		to: self;
+		
+		on: HLCompileErrorRaised
+		send: #onCompileError:
+		to: self;
+		
+		on: HLUnknownVariableErrorRaised
+		send: #onUnknownVariableError:
+		to: self;
+		
+		on: HLInstVarAdded 
+		send: #onInstVarAdded
+		to: self;
+		
+		on: HLMethodSelected 
+		send: #onMethodSelected:
+		to: self;
+		
+    	on: HLClassSelected 
+		send: #onClassSelected:
+		to: self;
+		
+		on: HLPackageSelected 
+		send: #onPackageSelected:
+		to: self;
+		
+    	on: HLProtocolSelected 
+		send: #onProtocolSelected: 
+		to: self;
+		
+		on: HLSourceCodeFocusRequested 
+		send: #onSourceCodeFocusRequested
+		to: self;
+		
+		on: HLShowTemplate
+		send: #onShowTemplate:
+		to: self
+!
+
+observeSystem
+	self browserModel systemAnnouncer
+    	on: MethodModified
+        send: #onMethodModified:
+		to: self
+!
+
+refresh
+	self hasModification ifTrue: [ ^ self ].
+    self hasFocus ifTrue: [ ^ self ].
+
+	self contents: self browserModel selectedMethod source
+!
+
+renderButtonsOn: html
+	html button 
+		class: 'button';
+		with: 'SaveIt';
+		onClick: [ self saveIt ].
+	super renderButtonsOn: html
+!
+
+saveIt
+	self browserModel saveSourceCode
+!
+
+unregister
+	super unregsiter.
+	
+	self browserModel announcer unsubscribe: self.
+	self browserModel systemAnnouncer unsubscribe: self
+! !
+
+!HLBrowserCodeWidget methodsFor: 'reactions'!
+
+onBrowserAboutToChange: anAnnouncement
+	| block |
+	
+	block := anAnnouncement actionBlock.
+	
+	self hasModification
+		ifTrue: [
+			self 
+				confirm: 'Changes have not been saved. Do you want to discard these changes?' 
+				ifTrue: [
+					"Don't ask twice"
+					self methodContents: self contents.
+					block value ].
+			
+			
+			HLChangeForbidden signal ]
+!
+
+onClassSelected: anAnnouncement
+	| class |
+	
+	class:= anAnnouncement item.
+	
+	class ifNil: [ ^ self contents: '' ].
+	self contents: class definition
+!
+
+onCompileError: anAnnouncement
+	self alert: anAnnouncement error messageText
+!
+
+onInstVarAdded
+	self browserModel save: self contents
+!
+
+onMethodModified: anAnnouncement
+	| method |
+	
+	method := anAnnouncement method.
+	
+	self browserModel selectedClass = method methodClass ifFalse: [ ^ self ].
+	self browserModel selectedMethod ifNil: [ ^ self ].
+	self browserModel selectedMethod selector = method selector ifFalse: [ ^ self ].
+
+	self refresh
+!
+
+onMethodSelected: anAnnouncement
+	| method |
+	
+	method := anAnnouncement item.
+	
+	method ifNil: [ ^ self contents: '' ].
+	self contents: method source
+!
+
+onPackageSelected: anAnnouncement
+	| package |
+	
+	package := anAnnouncement item.
+	
+	package ifNil: [ ^ self contents: '' ].
+	self contents: package definition
+!
+
+onParseError: anAnnouncement
+	| lineIndex newContents |
+	
+	lineIndex := 1.
+	
+	self contents: (String streamContents: [ :stream |
+		self contents linesDo: [ :each |
+			lineIndex = anAnnouncement line 
+				ifTrue: [ 
+					stream 
+						nextPutAll: (each copyFrom: 1 to: anAnnouncement column);
+						nextPutAll: '<- ';
+						nextPutAll: anAnnouncement message;
+						nextPutAll: ' ';
+						nextPutAll: (each copyFrom: anAnnouncement column + 1 to: each size) ]
+				ifFalse: [ stream nextPutAll: each ].
+			stream nextPutAll: String cr.
+			lineIndex := lineIndex + 1 ] ])
+!
+
+onProtocolSelected: anAnnouncement
+	self browserModel selectedClass ifNil: [ ^ self contents: '' ].
+	self contents: self browserModel selectedClass definition
+!
+
+onSaveIt
+	self browserModel save: self contents
+!
+
+onShowInstanceToggled
+	self browserModel selectedClass ifNil: [ ^ self contents: '' ].
+    
+	self contents: self browserModel selectedClass definition
+!
+
+onShowTemplate: anAnnouncement
+	self contents: anAnnouncement template
+!
+
+onSourceCodeFocusRequested
+	self focus
+!
+
+onSourceCodeSaved
+	self methodContents: self contents.
+	self updateState
+!
+
+onUnknownVariableError: anAnnouncement
+	| error |
+	
+	error := anAnnouncement error.
+	
+	self 
+		confirm: (String streamContents: [ :stream |
+			stream 
+				nextPutAll: error messageText;
+				nextPutAll: String cr;
+				nextPutAll: 'Would you like to define an instance variable?' ])
+		ifTrue: [
+			self browserModel addInstVarNamed: error variableName ]
+! !
+
+!HLBrowserCodeWidget class methodsFor: 'instance creation'!
+
+on: aBrowserModel
+	^ self new
+		browserModel: aBrowserModel;
+		yourself
+! !
+
+!HLBrowserCodeWidget class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ false
+! !
+
+HLWidget subclass: #HLWorkspace
+	instanceVariableNames: 'codeWidget transcript'
+	package: 'Helios-Workspace'!
+
+!HLWorkspace methodsFor: 'accessing'!
+
+codeWidget
+	^ codeWidget ifNil: [ codeWidget := HLCodeWidget new ]
+!
+
+transcript
+	^ transcript ifNil: [ transcript := HLTranscript new ]
+! !
+
+!HLWorkspace methodsFor: 'actions'!
+
+focus
+	^ self codeWidget focus
+!
+
+unregister
+	super unregister.
+	self transcript unregister
+! !
+
+!HLWorkspace methodsFor: 'rendering'!
+
+renderContentOn: html
+	html with: (HLContainer with: (HLHorizontalSplitter
+		with: self codeWidget
+		with: [ :canvas | self renderTranscriptOn: canvas ]))
+!
+
+renderTranscriptOn: html
+	html div 
+		class: 'transcript-container';
+		with: [
+			html div
+				class: 'list-label';
+				with: 'Transcript'.
+			self transcript renderOn: html ]
+! !
+
+!HLWorkspace methodsFor: 'testing'!
+
+canHaveFocus
+	^ true
+! !
+
+!HLWorkspace class methodsFor: 'accessing'!
+
+tabClass
+	^ 'workspace'
+!
+
+tabLabel
+	^ 'Workspace'
+!
+
+tabPriority
+	^ 10
+! !
+
+!HLWorkspace class methodsFor: 'testing'!
+
+canBeOpenAsTab
+	^ true
+! !
+