amber/js/Helios-Browser.js

smalltalk.addPackage('Helios-Browser', {});
smalltalk.addClass('HLBrowser', smalltalk.HLWidget, ['model', 'packagesListWidget', 'classesListWidget', 'protocolsListWidget', 'methodsListWidget', 'sourceWidget'], 'Helios-Browser');
smalltalk.addMethod(
"_announcer",
smalltalk.method({
selector: "announcer",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_announcer",[]);
return $1;
},
args: [],
source: "announcer\x0a\x09^ self model announcer",
messageSends: ["announcer", "model"],
referencedClasses: []
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_classesListWidget",
smalltalk.method({
selector: "classesListWidget",
category: 'widgets',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@classesListWidget"]) == nil || $receiver == undefined){
self["@classesListWidget"]=smalltalk.send((smalltalk.HLClassesListWidget || HLClassesListWidget),"_on_",[smalltalk.send(self,"_model",[])]);
self["@classesListWidget"];
$1=smalltalk.send(self["@classesListWidget"],"_next_",[smalltalk.send(self,"_protocolsListWidget",[])]);
} else {
$1=self["@classesListWidget"];
};
return $1;
},
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"]
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_environment",
smalltalk.method({
selector: "environment",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_environment",[]);
return $1;
},
args: [],
source: "environment\x0a\x09^ self model environment",
messageSends: ["environment", "model"],
referencedClasses: []
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_methodsListWidget",
smalltalk.method({
selector: "methodsListWidget",
category: 'widgets',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@methodsListWidget"]) == nil || $receiver == undefined){
self["@methodsListWidget"]=smalltalk.send((smalltalk.HLMethodsListWidget || HLMethodsListWidget),"_on_",[smalltalk.send(self,"_model",[])]);
$1=self["@methodsListWidget"];
} else {
$1=self["@methodsListWidget"];
};
return $1;
},
args: [],
source: "methodsListWidget\x0a\x09^ methodsListWidget ifNil: [\x0a      \x09methodsListWidget := HLMethodsListWidget on: self model ]",
messageSends: ["ifNil:", "on:", "model"],
referencedClasses: ["HLMethodsListWidget"]
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_model",
smalltalk.method({
selector: "model",
category: 'accessing',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@model"]) == nil || $receiver == undefined){
self["@model"]=smalltalk.send((smalltalk.HLBrowserModel || HLBrowserModel),"_new",[]);
$1=self["@model"];
} else {
$1=self["@model"];
};
return $1;
},
args: [],
source: "model\x0a\x09^ model ifNil: [ model := HLBrowserModel new ]",
messageSends: ["ifNil:", "new"],
referencedClasses: ["HLBrowserModel"]
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_model_",
smalltalk.method({
selector: "model:",
category: 'accessing',
fn: function (aModel){
var self=this;
self["@model"]=aModel;
return self},
args: ["aModel"],
source: "model: aModel\x0a\x09model := aModel",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_packagesListWidget",
smalltalk.method({
selector: "packagesListWidget",
category: 'widgets',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@packagesListWidget"]) == nil || $receiver == undefined){
self["@packagesListWidget"]=smalltalk.send((smalltalk.HLPackagesListWidget || HLPackagesListWidget),"_on_",[smalltalk.send(self,"_model",[])]);
self["@packagesListWidget"];
$1=smalltalk.send(self["@packagesListWidget"],"_next_",[smalltalk.send(self,"_classesListWidget",[])]);
} else {
$1=self["@packagesListWidget"];
};
return $1;
},
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"]
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_protocolsListWidget",
smalltalk.method({
selector: "protocolsListWidget",
category: 'widgets',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@protocolsListWidget"]) == nil || $receiver == undefined){
self["@protocolsListWidget"]=smalltalk.send((smalltalk.HLProtocolsListWidget || HLProtocolsListWidget),"_on_",[smalltalk.send(self,"_model",[])]);
self["@protocolsListWidget"];
$1=smalltalk.send(self["@protocolsListWidget"],"_next_",[smalltalk.send(self,"_methodsListWidget",[])]);
} else {
$1=self["@protocolsListWidget"];
};
return $1;
},
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"]
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_registerBindingsOn_",
smalltalk.method({
selector: "registerBindingsOn:",
category: 'keybindings',
fn: function (aBindingGroup){
var self=this;
var $1;
smalltalk.send(aBindingGroup,"_addGroupKey_labelled_",[(66),"Browse"]);
smalltalk.send(aBindingGroup,"_addGroupKey_labelled_",[(71),"Go to"]);
$1=smalltalk.send(aBindingGroup,"_addGroupKey_labelled_",[(84),"Toggle"]);
return self},
args: ["aBindingGroup"],
source: "registerBindingsOn: aBindingGroup\x0a\x09aBindingGroup \x0a    \x09addGroupKey: 66 labelled: 'Browse';\x0a        addGroupKey: 71 labelled: 'Go to';\x0a        addGroupKey: 84 labelled: 'Toggle'",
messageSends: ["addGroupKey:labelled:"],
referencedClasses: []
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_renderContentOn_",
smalltalk.method({
selector: "renderContentOn:",
category: 'rendering',
fn: function (html){
var self=this;
smalltalk.send(html,"_with_",[smalltalk.send((smalltalk.HLContainer || HLContainer),"_with_",[smalltalk.send((smalltalk.HLHorizontalSplitter || HLHorizontalSplitter),"_with_with_",[smalltalk.send((smalltalk.HLVerticalSplitter || HLVerticalSplitter),"_with_with_",[smalltalk.send((smalltalk.HLVerticalSplitter || HLVerticalSplitter),"_with_with_",[smalltalk.send(self,"_packagesListWidget",[]),smalltalk.send(self,"_classesListWidget",[])]),smalltalk.send((smalltalk.HLVerticalSplitter || HLVerticalSplitter),"_with_with_",[smalltalk.send(self,"_protocolsListWidget",[]),smalltalk.send(self,"_methodsListWidget",[])])]),smalltalk.send(self,"_sourceWidget",[])])])]);
return self},
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))",
messageSends: ["with:", "with:with:", "packagesListWidget", "classesListWidget", "protocolsListWidget", "methodsListWidget", "sourceWidget"],
referencedClasses: ["HLVerticalSplitter", "HLHorizontalSplitter", "HLContainer"]
}),
smalltalk.HLBrowser);

smalltalk.addMethod(
"_sourceWidget",
smalltalk.method({
selector: "sourceWidget",
category: 'widgets',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@sourceWidget"]) == nil || $receiver == undefined){
self["@sourceWidget"]=smalltalk.send((smalltalk.HLBrowserSourceWidget || HLBrowserSourceWidget),"_on_",[smalltalk.send(self,"_model",[])]);
$1=self["@sourceWidget"];
} else {
$1=self["@sourceWidget"];
};
return $1;
},
args: [],
source: "sourceWidget\x0a\x09^ sourceWidget ifNil: [\x0a      \x09sourceWidget := HLBrowserSourceWidget on: self model ]",
messageSends: ["ifNil:", "on:", "model"],
referencedClasses: ["HLBrowserSourceWidget"]
}),
smalltalk.HLBrowser);


smalltalk.HLBrowser.klass.iVarNames = ['nextId'];
smalltalk.addMethod(
"_canBeOpenAsTab",
smalltalk.method({
selector: "canBeOpenAsTab",
category: 'testing',
fn: function () {
    var self = this;
    return true;
},
args: [],
source: "canBeOpenAsTab\x0a\x09^ true",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowser.klass);

smalltalk.addMethod(
"_nextId",
smalltalk.method({
selector: "nextId",
category: 'accessing',
fn: function () {
    var self = this;
    var $1;
    if (($receiver = self['@nextId']) == nil || $receiver == undefined) {
        self['@nextId'] = 0;
        self['@nextId'];
    } else {
        self['@nextId'];
    }
    $1 = smalltalk.send("browser_", "__comma", [smalltalk.send(smalltalk.send(self['@nextId'], "__plus", [1]), "_asString", [])]);
    return $1;
},
args: [],
source: "nextId\x0a\x09nextId ifNil: [ nextId := 0 ].\x0a    ^ 'browser_', (nextId + 1) asString",
messageSends: ["ifNil:", ",", "asString", "+"],
referencedClasses: []
}),
smalltalk.HLBrowser.klass);

smalltalk.addMethod(
"_tabLabel",
smalltalk.method({
selector: "tabLabel",
category: 'accessing',
fn: function () {
    var self = this;
    return "Browser";
},
args: [],
source: "tabLabel\x0a\x09^ 'Browser'",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowser.klass);

smalltalk.addMethod(
"_tabPriority",
smalltalk.method({
selector: "tabPriority",
category: 'accessing',
fn: function () {
    var self = this;
    return 0;
},
args: [],
source: "tabPriority\x0a\x09^ 0",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowser.klass);


smalltalk.addClass('HLBrowserListWidget', smalltalk.HLNavigationListWidget, ['model'], 'Helios-Browser');
smalltalk.addMethod(
"_ensureSelection",
smalltalk.method({
selector: "ensureSelection",
category: 'actions',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(self,"_selectedItem",[]);
if(($receiver = $1) == nil || $receiver == undefined){
smalltalk.send(smalltalk.send(self,"_items",[]),"_ifNotEmpty_",[(function(){
smalltalk.send(self,"_selectItem_",[smalltalk.send(smalltalk.send(self,"_items",[]),"_first",[])]);
return smalltalk.send(self,"_refresh",[]);
})]);
} else {
smalltalk.send(self,"_selectItem_",[smalltalk.send(self,"_selectedItem",[])]);
};
return self},
args: [],
source: "ensureSelection\x0a\x09self selectedItem \x0a    \x09ifNil: [\x0a      \x09\x09self items ifNotEmpty: [\x0a  \x09\x09\x09\x09self selectItem: self items first.\x0a  \x09\x09\x09\x09self refresh ] ]\x0a\x09\x09ifNotNil: [ self selectItem: self selectedItem ]",
messageSends: ["ifNil:ifNotNil:", "ifNotEmpty:", "selectItem:", "first", "items", "refresh", "selectedItem"],
referencedClasses: []
}),
smalltalk.HLBrowserListWidget);

smalltalk.addMethod(
"_focus",
smalltalk.method({
selector: "focus",
category: 'events',
fn: function (){
var self=this;
smalltalk.send(self,"_focus",[],smalltalk.HLNavigationListWidget);
smalltalk.send(self,"_ensureSelection",[]);
return self},
args: [],
source: "focus\x0a\x09super focus.\x0a    self ensureSelection",
messageSends: ["focus", "ensureSelection"],
referencedClasses: []
}),
smalltalk.HLBrowserListWidget);

smalltalk.addMethod(
"_model",
smalltalk.method({
selector: "model",
category: 'accessing',
fn: function (){
var self=this;
return self["@model"];
},
args: [],
source: "model\x0a\x09^ model",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserListWidget);

smalltalk.addMethod(
"_model_",
smalltalk.method({
selector: "model:",
category: 'accessing',
fn: function (aBrowserModel){
var self=this;
self["@model"]=aBrowserModel;
smalltalk.send(self["@model"],"_subscribe_",[self]);
return self},
args: ["aBrowserModel"],
source: "model: aBrowserModel\x0a\x09\x22TODO: unsubscribe from previous model\x22\x0a    \x0a\x09model := aBrowserModel.\x0a    model subscribe: self",
messageSends: ["subscribe:"],
referencedClasses: []
}),
smalltalk.HLBrowserListWidget);


smalltalk.addMethod(
"_on_",
smalltalk.method({
selector: "on:",
category: 'instance creation',
fn: function (aModel){
var self=this;
var $2,$3,$1;
$2=smalltalk.send(self,"_new",[]);
smalltalk.send($2,"_model_",[aModel]);
$3=smalltalk.send($2,"_yourself",[]);
$1=$3;
return $1;
},
args: ["aModel"],
source: "on: aModel\x0a\x09^ self new \x0a    \x09model: aModel;\x0a        yourself",
messageSends: ["model:", "new", "yourself"],
referencedClasses: []
}),
smalltalk.HLBrowserListWidget.klass);


smalltalk.addClass('HLClassesListWidget', smalltalk.HLBrowserListWidget, [], 'Helios-Browser');
smalltalk.addMethod(
"_focusMethodsListWidget",
smalltalk.method({
selector: "focusMethodsListWidget",
category: 'actions',
fn: function (){
var self=this;
smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLMethodsListFocus || HLMethodsListFocus),"_new",[])]);
return self},
args: [],
source: "focusMethodsListWidget\x0a\x09self model announcer announce: HLMethodsListFocus new",
messageSends: ["announce:", "new", "announcer", "model"],
referencedClasses: ["HLMethodsListFocus"]
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_focusProtocolsListWidget",
smalltalk.method({
selector: "focusProtocolsListWidget",
category: 'actions',
fn: function (){
var self=this;
smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLProtocolsListFocus || HLProtocolsListFocus),"_new",[])]);
return self},
args: [],
source: "focusProtocolsListWidget\x0a\x09self model announcer announce: HLProtocolsListFocus new",
messageSends: ["announce:", "new", "announcer", "model"],
referencedClasses: ["HLProtocolsListFocus"]
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_getChildrenOf_",
smalltalk.method({
selector: "getChildrenOf:",
category: 'accessing',
fn: function (aClass){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_items",[]),"_select_",[(function(each){
return smalltalk.send(smalltalk.send(each,"_superclass",[]),"__eq",[aClass]);
})]);
return $1;
},
args: ["aClass"],
source: "getChildrenOf: aClass\x0a\x09^ self items select: [ :each | each superclass = aClass ]",
messageSends: ["select:", "=", "superclass", "items"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_getRootClassesOf_",
smalltalk.method({
selector: "getRootClassesOf:",
category: 'accessing',
fn: function (aCollection){
var self=this;
var $1;
$1=smalltalk.send(aCollection,"_select_",[(function(each){
return smalltalk.send(smalltalk.send(smalltalk.send(each,"_allSuperclasses",[]),"_intersection_",[aCollection]),"_isEmpty",[]);
})]);
return $1;
},
args: ["aCollection"],
source: "getRootClassesOf: aCollection\x0a\x09^ aCollection select: [ :each |\x0a    \x09(each allSuperclasses intersection: aCollection) isEmpty ]",
messageSends: ["select:", "isEmpty", "intersection:", "allSuperclasses"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_iconForItem_",
smalltalk.method({
selector: "iconForItem:",
category: 'accessing',
fn: function (aClass){
var self=this;
var $2,$1;
$2=smalltalk.send(smalltalk.send(smalltalk.send(aClass,"_theNonMetaClass",[]),"_comment",[]),"_isEmpty",[]);
if(smalltalk.assert($2)){
$1="icon-question-sign";
} else {
$1="icon-none";
};
return $1;
},
args: ["aClass"],
source: "iconForItem: aClass\x0a\x09^ aClass theNonMetaClass comment isEmpty\x0a    \x09ifFalse: [ 'icon-none' ]\x0a      \x09ifTrue: [ 'icon-question-sign' ]",
messageSends: ["ifFalse:ifTrue:", "isEmpty", "comment", "theNonMetaClass"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_packageSelected_",
smalltalk.method({
selector: "packageSelected:",
category: 'actions',
fn: function (aPackage){
var self=this;
var $1;
smalltalk.send(self,"_selectedItem_",[nil]);
if(($receiver = aPackage) == nil || $receiver == undefined){
$1=[];
} else {
$1=smalltalk.send(smalltalk.send(smalltalk.send(smalltalk.send(aPackage,"_classes",[]),"_collect_",[(function(each){
return smalltalk.send(each,"_theNonMetaClass",[]);
})]),"_asSet",[]),"_asArray",[]);
};
smalltalk.send(self,"_items_",[$1]);
smalltalk.send(self,"_refresh",[]);
return self},
args: ["aPackage"],
source: "packageSelected: aPackage\x0a    self selectedItem: nil.\x0a    \x0a    self items: (aPackage \x0a    \x09ifNil: [ #() ]\x0a  \x09\x09ifNotNil: [ (aPackage classes \x0a        \x09collect: [ :each | each theNonMetaClass ]) asSet asArray ]).\x0a\x0a    self refresh",
messageSends: ["selectedItem:", "items:", "ifNil:ifNotNil:", "asArray", "asSet", "collect:", "theNonMetaClass", "classes", "refresh"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_registerBindingsOn_",
smalltalk.method({
selector: "registerBindingsOn:",
category: 'keybindings',
fn: function (aBindingGroup){
var self=this;
var $1,$2;
smalltalk.send(smalltalk.send(aBindingGroup,"_at_",["Go to"]),"_addActionKey_labelled_callback_",[(67),"Classes",(function(){
return smalltalk.send(self,"_focus",[]);
})]);
$1=smalltalk.send(aBindingGroup,"_at_",["Toggle"]);
smalltalk.send($1,"_addActionKey_labelled_callback_",[(73),"Instance side",(function(){
return smalltalk.send(self,"_showInstance_",[true]);
})]);
$2=smalltalk.send($1,"_addActionKey_labelled_callback_",[(67),"Class side",(function(){
return smalltalk.send(self,"_showInstance_",[false]);
})]);
return self},
args: ["aBindingGroup"],
source: "registerBindingsOn: aBindingGroup\x0a\x09(aBindingGroup at: 'Go to') \x0a    \x09addActionKey: 67 labelled: 'Classes' callback: [ self focus ].\x0a    (aBindingGroup at: 'Toggle') \x0a    \x09addActionKey: 73 labelled: 'Instance side' callback: [ self showInstance: true ];\x0a        addActionKey: 67 labelled: 'Class side' callback: [  self showInstance: false ]",
messageSends: ["addActionKey:labelled:callback:", "focus", "at:", "showInstance:"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_renderButtonsOn_",
smalltalk.method({
selector: "renderButtonsOn:",
category: 'rendering',
fn: function (html){
var self=this;
var $1,$3,$4,$5,$6,$7,$8,$2,$9,$10;
$1=smalltalk.send(html,"_div",[]);
smalltalk.send($1,"_class_",["btn-group"]);
smalltalk.send($1,"_at_put_",["data-toggle","buttons-radio"]);
$2=smalltalk.send($1,"_with_",[(function(){
$3=smalltalk.send(html,"_button",[]);
smalltalk.send($3,"_class_",[smalltalk.send((smalltalk.String || String),"_streamContents_",[(function(str){
smalltalk.send(str,"_nextPutAll_",["btn"]);
$4=smalltalk.send(self,"_showInstance",[]);
if(smalltalk.assert($4)){
return smalltalk.send(str,"_nextPutAll_",[" active"]);
};
})])]);
smalltalk.send($3,"_with_",["Instance"]);
$5=smalltalk.send($3,"_onClick_",[(function(){
return smalltalk.send(self,"_showInstance_",[true]);
})]);
$5;
$6=smalltalk.send(html,"_button",[]);
smalltalk.send($6,"_class_",[smalltalk.send((smalltalk.String || String),"_streamContents_",[(function(str){
smalltalk.send(str,"_nextPutAll_",["btn"]);
$7=smalltalk.send(smalltalk.send(self,"_model",[]),"_showInstance",[]);
if(! smalltalk.assert($7)){
return smalltalk.send(str,"_nextPutAll_",[" active"]);
};
})])]);
smalltalk.send($6,"_with_",["Class"]);
$8=smalltalk.send($6,"_onClick_",[(function(){
return smalltalk.send(smalltalk.send(self,"_model",[]),"_showInstance_",[false]);
})]);
return $8;
})]);
$9=smalltalk.send(html,"_button",[]);
smalltalk.send($9,"_class_",["btn"]);
smalltalk.send($9,"_at_put_",["data-toggle","button"]);
$10=smalltalk.send($9,"_with_",["Comment"]);
return self},
args: ["html"],
source: "renderButtonsOn: html\x0a\x09html div \x0a        class: 'btn-group';\x0a\x09\x09at: 'data-toggle' put: 'buttons-radio';\x0a\x09\x09with: [ \x0a           \x09html button \x0a                class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showInstance ifTrue: [ \x0a                    \x09str nextPutAll: ' active'] ]);\x0a  \x09\x09\x09\x09with: 'Instance';\x0a                onClick: [ self showInstance: true ].\x0a  \x09\x09\x09html button\x0a  \x09\x09\x09\x09class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self model showInstance ifFalse: [ \x0a                    \x09str nextPutAll: ' active'] ]);\x0a  \x09\x09\x09\x09with: 'Class';\x0a\x09\x09\x09\x09onClick: [ self model showInstance: false ] ].\x0a                 \x0a  \x09html button \x0a           \x09class: 'btn';\x0a            at: 'data-toggle' put: 'button';\x0a  \x09\x09\x09with: 'Comment'",
messageSends: ["class:", "div", "at:put:", "with:", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "button", "onClick:", "showInstance:", "ifFalse:", "model"],
referencedClasses: ["String"]
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_renderItem_level_on_",
smalltalk.method({
selector: "renderItem:level:on:",
category: 'rendering',
fn: function (aClass,anInteger,html){
var self=this;
var $2,$3,$1;
var li;
li=smalltalk.send(html,"_li",[]);
smalltalk.send(li,"_at_put_",["list-data",smalltalk.send(smalltalk.send(self,"_items",[]),"_indexOf_",[aClass])]);
smalltalk.send(li,"_class_",[smalltalk.send(self,"_cssClassForItem_",[aClass])]);
$1=smalltalk.send(li,"_with_",[(function(){
$2=smalltalk.send(html,"_a",[]);
smalltalk.send($2,"_with_",[(function(){
smalltalk.send(smalltalk.send(html,"_tag_",["i"]),"_class_",[smalltalk.send(self,"_iconForItem_",[aClass])]);
return smalltalk.send(self,"_renderItemLabel_level_on_",[aClass,anInteger,html]);
})]);
$3=smalltalk.send($2,"_onClick_",[(function(){
return smalltalk.send(self,"_activateListItem_",[smalltalk.send(li,"_asJQuery",[])]);
})]);
return $3;
})]);
smalltalk.send(smalltalk.send(self,"_getChildrenOf_",[aClass]),"_do_",[(function(each){
return smalltalk.send(self,"_renderItem_level_on_",[each,smalltalk.send(anInteger,"__plus",[(1)]),html]);
})]);
return self},
args: ["aClass", "anInteger", "html"],
source: "renderItem: aClass level: anInteger on: html\x0a\x09| li |\x0a    \x0a\x09li := html li.\x0a    li\x0a    \x09at: 'list-data' put: (self items indexOf: aClass);\x0a    \x09class: (self cssClassForItem: aClass);\x0a        with: [ \x0a        \x09html a\x0a            \x09with: [ \x0a            \x09\x09(html tag: 'i') class: (self iconForItem: aClass).\x0a  \x09\x09\x09\x09\x09self renderItemLabel: aClass level: anInteger on: html ];\x0a\x09\x09\x09\x09onClick: [\x0a                  \x09self activateListItem: li asJQuery ] ].\x0a                    \x0a    (self getChildrenOf: aClass) do: [ :each |\x0a    \x09self renderItem: each level: anInteger + 1 on: html ]",
messageSends: ["li", "at:put:", "indexOf:", "items", "class:", "cssClassForItem:", "with:", "iconForItem:", "tag:", "renderItemLabel:level:on:", "a", "onClick:", "activateListItem:", "asJQuery", "do:", "renderItem:level:on:", "+", "getChildrenOf:"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_renderItem_on_",
smalltalk.method({
selector: "renderItem:on:",
category: 'rendering',
fn: function (aClass,html){
var self=this;
smalltalk.send(self,"_renderItem_on_",[aClass,html],smalltalk.HLBrowserListWidget);
smalltalk.send(smalltalk.send(self,"_getChildrenOf_",[aClass]),"_do_",[(function(each){
return smalltalk.send(self,"_renderItem_level_on_",[each,(1),html]);
})]);
return self},
args: ["aClass", "html"],
source: "renderItem: aClass on: html\x0a\x09super renderItem: aClass on: html.\x0a    \x09(self getChildrenOf: aClass) do: [ :each |\x0a    \x09\x09self renderItem: each level: 1 on: html ]",
messageSends: ["renderItem:on:", "do:", "renderItem:level:on:", "getChildrenOf:"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_renderItemLabel_level_on_",
smalltalk.method({
selector: "renderItemLabel:level:on:",
category: 'rendering',
fn: function (aClass,anInteger,html){
var self=this;
smalltalk.send(smalltalk.send(smalltalk.send(html,"_span",[]),"_asJQuery",[]),"_html_",[smalltalk.send((smalltalk.String || String),"_streamContents_",[(function(str){
smalltalk.send(anInteger,"_timesRepeat_",[(function(){
return smalltalk.send(str,"_nextPutAll_",["    "]);
})]);
return smalltalk.send(str,"_nextPutAll_",[smalltalk.send(aClass,"_name",[])]);
})])]);
return self},
args: ["aClass", "anInteger", "html"],
source: "renderItemLabel: aClass level: anInteger on: html\x0a\x09html span asJQuery html: (String streamContents: [ :str |\x0a\x09\x09anInteger timesRepeat: [\x0a\x09\x09\x09str nextPutAll: '    '].\x0a\x09\x09\x09str nextPutAll: aClass name ])",
messageSends: ["html:", "streamContents:", "timesRepeat:", "nextPutAll:", "name", "asJQuery", "span"],
referencedClasses: ["String"]
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_renderItemLabel_on_",
smalltalk.method({
selector: "renderItemLabel:on:",
category: 'rendering',
fn: function (aClass,html){
var self=this;
smalltalk.send(self,"_renderItemLabel_level_on_",[aClass,(0),html]);
return self},
args: ["aClass", "html"],
source: "renderItemLabel: aClass on: html\x0a\x09self renderItemLabel: aClass level: 0 on: html",
messageSends: ["renderItemLabel:level:on:"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_renderListOn_",
smalltalk.method({
selector: "renderListOn:",
category: 'rendering',
fn: function (html){
var self=this;
smalltalk.send(smalltalk.send(self,"_getRootClassesOf_",[smalltalk.send(self,"_items",[])]),"_do_",[(function(each){
return smalltalk.send(self,"_renderItem_on_",[each,html]);
})]);
return self},
args: ["html"],
source: "renderListOn: html\x0a\x09(self getRootClassesOf: self items)\x0a    \x09do: [ :each | self renderItem: each on: html ]",
messageSends: ["do:", "renderItem:on:", "getRootClassesOf:", "items"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_selectItem_",
smalltalk.method({
selector: "selectItem:",
category: 'actions',
fn: function (aClass){
var self=this;
smalltalk.send(self,"_selectItem_",[aClass],smalltalk.HLBrowserListWidget);
smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass_",[aClass]);
return self},
args: ["aClass"],
source: "selectItem: aClass\x0a\x09super selectItem: aClass.\x0a    self model selectedClass: aClass",
messageSends: ["selectItem:", "selectedClass:", "model"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_showInstance",
smalltalk.method({
selector: "showInstance",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_showInstance",[]);
return $1;
},
args: [],
source: "showInstance\x0a\x09^ self model showInstance",
messageSends: ["showInstance", "model"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_showInstance_",
smalltalk.method({
selector: "showInstance:",
category: 'actions',
fn: function (aBoolean){
var self=this;
smalltalk.send(smalltalk.send(self,"_model",[]),"_showInstance_",[aBoolean]);
return self},
args: ["aBoolean"],
source: "showInstance: aBoolean\x0a\x09self model showInstance: aBoolean",
messageSends: ["showInstance:", "model"],
referencedClasses: []
}),
smalltalk.HLClassesListWidget);

smalltalk.addMethod(
"_subscribeTo_",
smalltalk.method({
selector: "subscribeTo:",
category: 'announcements',
fn: function (anAnnouncer){
var self=this;
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLPackageSelected || HLPackageSelected),(function(ann){
return smalltalk.send(self,"_packageSelected_",[smalltalk.send(ann,"_item",[])]);
})]);
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLShowInstanceToggled || HLShowInstanceToggled),(function(ann){
return smalltalk.send(self,"_refresh",[]);
})]);
return self},
args: ["anAnnouncer"],
source: "subscribeTo: anAnnouncer\x0a\x09anAnnouncer on: HLPackageSelected do: [ :ann |\x0a    \x09self packageSelected: ann item ].\x0a    anAnnouncer on: HLShowInstanceToggled do: [ :ann |\x0a    \x09self refresh ]",
messageSends: ["on:do:", "packageSelected:", "item", "refresh"],
referencedClasses: ["HLPackageSelected", "HLShowInstanceToggled"]
}),
smalltalk.HLClassesListWidget);



smalltalk.addClass('HLMethodsListWidget', smalltalk.HLBrowserListWidget, ['selectorsCache'], 'Helios-Browser');
smalltalk.addMethod(
"_allProtocol",
smalltalk.method({
selector: "allProtocol",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_allProtocol",[]);
return $1;
},
args: [],
source: "allProtocol\x0a\x09^ self model allProtocol",
messageSends: ["allProtocol", "model"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_flushSelectorsCache",
smalltalk.method({
selector: "flushSelectorsCache",
category: 'cache',
fn: function (){
var self=this;
self["@selectorsCache"]=smalltalk.send((smalltalk.Dictionary || Dictionary),"_new",[]);
return self},
args: [],
source: "flushSelectorsCache\x0a\x09selectorsCache := Dictionary new",
messageSends: ["new"],
referencedClasses: ["Dictionary"]
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_iconForItem_",
smalltalk.method({
selector: "iconForItem:",
category: 'accessing',
fn: function (aCompiledMethod){
var self=this;
var $1;
var override;
var overriden;
override=smalltalk.send(self,"_isOverride_",[aCompiledMethod]);
overriden=smalltalk.send(self,"_isOverriden_",[aCompiledMethod]);
if(smalltalk.assert(override)){
if(smalltalk.assert(overriden)){
$1="icon-resize-vertical";
} else {
$1="icon-arrow-up";
};
} else {
if(smalltalk.assert(overriden)){
$1="icon-arrow-down";
} else {
$1="icon-none";
};
};
return $1;
},
args: ["aCompiledMethod"],
source: "iconForItem: aCompiledMethod\x0a\x09| override overriden |\x0a    \x0a    override := self isOverride: aCompiledMethod.\x0a    overriden := self isOverriden: aCompiledMethod.\x0a    \x0a\x09^ override\x0a    \x09ifTrue: [ overriden\x0a\x09\x09\x09ifTrue: [ 'icon-resize-vertical' ]\x0a\x09\x09\x09ifFalse: [ 'icon-arrow-up' ] ]\x0a\x09\x09ifFalse: [\x0a\x09\x09\x09overriden\x0a\x09\x09\x09ifTrue: [ 'icon-arrow-down' ]\x0a\x09\x09\x09ifFalse: [ 'icon-none' ] ]",
messageSends: ["isOverride:", "isOverriden:", "ifTrue:ifFalse:"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_initialize",
smalltalk.method({
selector: "initialize",
category: 'initialization',
fn: function (){
var self=this;
smalltalk.send(self,"_initialize",[],smalltalk.HLBrowserListWidget);
smalltalk.send(self,"_flushSelectorsCache",[]);
return self},
args: [],
source: "initialize\x0a\x09super initialize.\x0a    self flushSelectorsCache",
messageSends: ["initialize", "flushSelectorsCache"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_isOverride_",
smalltalk.method({
selector: "isOverride:",
category: 'testing',
fn: function (aMethod){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_overrideSelectors",[]),"_includes_",[smalltalk.send(aMethod,"_selector",[])]);
return $1;
},
args: ["aMethod"],
source: "isOverride: aMethod\x0a\x0a   ^ self overrideSelectors includes: aMethod selector",
messageSends: ["includes:", "selector", "overrideSelectors"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_isOverriden_",
smalltalk.method({
selector: "isOverriden:",
category: 'testing',
fn: function (aMethod){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_overridenSelectors",[]),"_includes_",[smalltalk.send(aMethod,"_selector",[])]);
return $1;
},
args: ["aMethod"],
source: "isOverriden: aMethod\x0a\x0a   ^ self overridenSelectors includes: aMethod selector",
messageSends: ["includes:", "selector", "overridenSelectors"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_methodsInProtocol_",
smalltalk.method({
selector: "methodsInProtocol:",
category: 'accessing',
fn: function (aString){
var self=this;
var $2,$1;
$2=smalltalk.send(aString,"__eq",[smalltalk.send(self,"_allProtocol",[])]);
if(smalltalk.assert($2)){
$1=smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]),"_methods",[]);
} else {
$1=smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]),"_methodsInProtocol_",[aString]);
};
return $1;
},
args: ["aString"],
source: "methodsInProtocol: aString\x0a\x09^ aString = self allProtocol\x0a    \x09ifTrue: [ self model selectedClass methods ]\x0a      \x09ifFalse: [ self model selectedClass methodsInProtocol: aString ]",
messageSends: ["ifTrue:ifFalse:", "methods", "selectedClass", "model", "methodsInProtocol:", "=", "allProtocol"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_overrideSelectors",
smalltalk.method({
selector: "overrideSelectors",
category: 'accessing',
fn: function (){
var self=this;
var $2,$1;
$1=smalltalk.send(smalltalk.send(self,"_selectorsCache",[]),"_at_ifAbsentPut_",["override",(function(){
return smalltalk.send(smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]),"_allSuperclasses",[]),"_inject_into_",[smalltalk.send((smalltalk.Set || Set),"_new",[]),(function(acc,each){
smalltalk.send(acc,"_addAll_",[smalltalk.send(each,"_selectors",[])]);
$2=smalltalk.send(acc,"_yourself",[]);
return $2;
})]);
})]);
return $1;
},
args: [],
source: "overrideSelectors\x0a\x09^ self selectorsCache \x0a    \x09at: 'override'\x0a        ifAbsentPut: [ \x0a        \x09self model selectedClass allSuperclasses\x0a\x09\x09\x09\x09inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]",
messageSends: ["at:ifAbsentPut:", "inject:into:", "new", "addAll:", "selectors", "yourself", "allSuperclasses", "selectedClass", "model", "selectorsCache"],
referencedClasses: ["Set"]
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_overridenSelectors",
smalltalk.method({
selector: "overridenSelectors",
category: 'accessing',
fn: function (){
var self=this;
var $2,$1;
$1=smalltalk.send(smalltalk.send(self,"_selectorsCache",[]),"_at_ifAbsentPut_",["overriden",(function(){
return smalltalk.send(smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]),"_allSubclasses",[]),"_inject_into_",[smalltalk.send((smalltalk.Set || Set),"_new",[]),(function(acc,each){
smalltalk.send(acc,"_addAll_",[smalltalk.send(each,"_selectors",[])]);
$2=smalltalk.send(acc,"_yourself",[]);
return $2;
})]);
})]);
return $1;
},
args: [],
source: "overridenSelectors\x0a\x09^ self selectorsCache \x0a    \x09at: 'overriden'\x0a        ifAbsentPut: [ \x0a        \x09self model selectedClass allSubclasses\x0a\x09\x09\x09\x09inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]",
messageSends: ["at:ifAbsentPut:", "inject:into:", "new", "addAll:", "selectors", "yourself", "allSubclasses", "selectedClass", "model", "selectorsCache"],
referencedClasses: ["Set"]
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_protocolSelected_",
smalltalk.method({
selector: "protocolSelected:",
category: 'actions',
fn: function (aString){
var self=this;
var $2,$1;
smalltalk.send(self,"_selectedItem_",[nil]);
$2=smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]);
if(($receiver = $2) == nil || $receiver == undefined){
$1=[];
} else {
if(($receiver = aString) == nil || $receiver == undefined){
$1=smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]),"_methods",[]);
} else {
$1=smalltalk.send(self,"_methodsInProtocol_",[aString]);
};
};
smalltalk.send(self,"_items_",[$1]);
smalltalk.send(self,"_refresh",[]);
return self},
args: ["aString"],
source: "protocolSelected: aString\x0a    self selectedItem: nil.\x0a    \x0a    self items: (self model selectedClass \x0a    \x09ifNil: [ #() ]\x0a      \x09ifNotNil: [ aString\x0a    \x09\x09ifNil: [ self model selectedClass methods ]\x0a      \x09\x09ifNotNil: [ self methodsInProtocol: aString ] ]).\x0a        \x0a    self refresh",
messageSends: ["selectedItem:", "items:", "ifNil:ifNotNil:", "methods", "selectedClass", "model", "methodsInProtocol:", "refresh"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_registerBindingsOn_",
smalltalk.method({
selector: "registerBindingsOn:",
category: 'keybindings',
fn: function (aBindingGroup){
var self=this;
smalltalk.send(smalltalk.send(aBindingGroup,"_at_",["Go to"]),"_addActionKey_labelled_callback_",[(77),"Methods",(function(){
return smalltalk.send(self,"_focus",[]);
})]);
return self},
args: ["aBindingGroup"],
source: "registerBindingsOn: aBindingGroup\x0a\x09(aBindingGroup at: 'Go to') \x0a    \x09addActionKey: 77 labelled: 'Methods' callback: [ self focus ]",
messageSends: ["addActionKey:labelled:callback:", "focus", "at:"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_renderContentOn_",
smalltalk.method({
selector: "renderContentOn:",
category: 'rendering',
fn: function (html){
var self=this;
var $1,$2,$3;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_showInstance",[]);
if(smalltalk.assert($1)){
smalltalk.send(self,"_renderContentOn_",[html],smalltalk.HLBrowserListWidget);
} else {
$2=smalltalk.send(html,"_div",[]);
smalltalk.send($2,"_class_",["class_side"]);
$3=smalltalk.send($2,"_with_",[(function(){
return smalltalk.send(self,"_renderContentOn_",[html],smalltalk.HLBrowserListWidget);
})]);
$3;
};
smalltalk.send(self,"_flushSelectorsCache",[]);
return self},
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 ].\x0a        \x0a    self flushSelectorsCache",
messageSends: ["ifFalse:ifTrue:", "class:", "div", "with:", "renderContentOn:", "showInstance", "model", "flushSelectorsCache"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_renderItemLabel_on_",
smalltalk.method({
selector: "renderItemLabel:on:",
category: 'rendering',
fn: function (aCompiledMethod,html){
var self=this;
smalltalk.send(html,"_with_",[smalltalk.send(aCompiledMethod,"_selector",[])]);
return self},
args: ["aCompiledMethod", "html"],
source: "renderItemLabel: aCompiledMethod on: html\x0a\x09html with: aCompiledMethod selector",
messageSends: ["with:", "selector"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_selectItem_",
smalltalk.method({
selector: "selectItem:",
category: 'actions',
fn: function (aCompiledMethod){
var self=this;
smalltalk.send(self,"_selectItem_",[aCompiledMethod],smalltalk.HLBrowserListWidget);
smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedMethod_",[aCompiledMethod]);
return self},
args: ["aCompiledMethod"],
source: "selectItem: aCompiledMethod\x0a\x09super selectItem: aCompiledMethod.\x0a    self model selectedMethod: aCompiledMethod",
messageSends: ["selectItem:", "selectedMethod:", "model"],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_selectorsCache",
smalltalk.method({
selector: "selectorsCache",
category: 'accessing',
fn: function (){
var self=this;
return self["@selectorsCache"];
},
args: [],
source: "selectorsCache\x0a\x09^ selectorsCache",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLMethodsListWidget);

smalltalk.addMethod(
"_subscribeTo_",
smalltalk.method({
selector: "subscribeTo:",
category: 'announcements',
fn: function (anAnnouncer){
var self=this;
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLProtocolSelected || HLProtocolSelected),(function(ann){
return smalltalk.send(self,"_protocolSelected_",[smalltalk.send(ann,"_item",[])]);
})]);
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLShowInstanceToggled || HLShowInstanceToggled),(function(ann){
return smalltalk.send(self,"_protocolSelected_",[nil]);
})]);
return self},
args: ["anAnnouncer"],
source: "subscribeTo: anAnnouncer\x0a\x09anAnnouncer on: HLProtocolSelected do: [ :ann |\x0a    \x09self protocolSelected: ann item ].\x0a    anAnnouncer on: HLShowInstanceToggled do: [ :ann |\x0a    \x09self protocolSelected: nil ]",
messageSends: ["on:do:", "protocolSelected:", "item"],
referencedClasses: ["HLProtocolSelected", "HLShowInstanceToggled"]
}),
smalltalk.HLMethodsListWidget);



smalltalk.addClass('HLPackagesListWidget', smalltalk.HLBrowserListWidget, [], 'Helios-Browser');
smalltalk.addMethod(
"_focusClassesListWidget",
smalltalk.method({
selector: "focusClassesListWidget",
category: 'actions',
fn: function (){
var self=this;
smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLClassesListFocus || HLClassesListFocus),"_new",[])]);
return self},
args: [],
source: "focusClassesListWidget\x0a\x09self model announcer announce: HLClassesListFocus new",
messageSends: ["announce:", "new", "announcer", "model"],
referencedClasses: ["HLClassesListFocus"]
}),
smalltalk.HLPackagesListWidget);

smalltalk.addMethod(
"_items",
smalltalk.method({
selector: "items",
category: 'accessing',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@items"]) == nil || $receiver == undefined){
self["@items"]=smalltalk.send(smalltalk.send(self,"_model",[]),"_packages",[]);
$1=self["@items"];
} else {
$1=self["@items"];
};
return $1;
},
args: [],
source: "items\x0a\x09^ items ifNil: [ items := self model packages ]",
messageSends: ["ifNil:", "packages", "model"],
referencedClasses: []
}),
smalltalk.HLPackagesListWidget);

smalltalk.addMethod(
"_registerBindingsOn_",
smalltalk.method({
selector: "registerBindingsOn:",
category: 'keybindings',
fn: function (aBindingGroup){
var self=this;
smalltalk.send(smalltalk.send(aBindingGroup,"_at_",["Go to"]),"_addActionKey_labelled_callback_",[(80),"Packages",(function(){
return smalltalk.send(self,"_focus",[]);
})]);
return self},
args: ["aBindingGroup"],
source: "registerBindingsOn: aBindingGroup\x0a\x09(aBindingGroup at: 'Go to') \x0a    \x09addActionKey: 80 labelled: 'Packages' callback: [ self focus ]",
messageSends: ["addActionKey:labelled:callback:", "focus", "at:"],
referencedClasses: []
}),
smalltalk.HLPackagesListWidget);

smalltalk.addMethod(
"_renderButtonsOn_",
smalltalk.method({
selector: "renderButtonsOn:",
category: 'rendering',
fn: function (html){
var self=this;
var $1,$2,$3,$5,$6,$7,$8,$4,$9,$10;
$1=smalltalk.send(html,"_span",[]);
smalltalk.send($1,"_class_",["info"]);
$2=smalltalk.send($1,"_with_",["Auto commit"]);
$3=smalltalk.send(html,"_div",[]);
smalltalk.send($3,"_class_",["btn-group switch"]);
smalltalk.send($3,"_at_put_",["data-toggle","buttons-radio"]);
$4=smalltalk.send($3,"_with_",[(function(){
$5=smalltalk.send(html,"_button",[]);
smalltalk.send($5,"_class_",[smalltalk.send((smalltalk.String || String),"_streamContents_",[(function(str){
return smalltalk.send(str,"_nextPutAll_",["btn"]);
})])]);
$6=smalltalk.send($5,"_with_",["On"]);
$6;
$7=smalltalk.send(html,"_button",[]);
smalltalk.send($7,"_class_",[smalltalk.send((smalltalk.String || String),"_streamContents_",[(function(str){
return smalltalk.send(str,"_nextPutAll_",["btn active"]);
})])]);
$8=smalltalk.send($7,"_with_",["Off"]);
return $8;
})]);
$9=smalltalk.send(html,"_a",[]);
smalltalk.send($9,"_class_",["btn"]);
$10=smalltalk.send($9,"_with_",["Commit"]);
return self},
args: ["html"],
source: "renderButtonsOn: html\x0a\x0a\x09html span class: 'info'; with: 'Auto commit'.\x0a\x09html div \x0a        class: 'btn-group switch';\x0a\x09\x09at: 'data-toggle' put: 'buttons-radio';\x0a\x09\x09with: [ \x0a           \x09html button \x0a                class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn' ]);\x0a  \x09\x09\x09\x09with: 'On'.\x0a  \x09\x09\x09html button\x0a  \x09\x09\x09\x09class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn active' ]);\x0a  \x09\x09\x09\x09with: 'Off' ].\x0a                \x0a    html a \x0a         \x09class: 'btn';\x0a\x09\x09\x09with: 'Commit'.",
messageSends: ["class:", "span", "with:", "div", "at:put:", "streamContents:", "nextPutAll:", "button", "a"],
referencedClasses: ["String"]
}),
smalltalk.HLPackagesListWidget);

smalltalk.addMethod(
"_selectItem_",
smalltalk.method({
selector: "selectItem:",
category: 'actions',
fn: function (aPackage){
var self=this;
smalltalk.send(self,"_selectItem_",[aPackage],smalltalk.HLBrowserListWidget);
smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedPackage_",[aPackage]);
return self},
args: ["aPackage"],
source: "selectItem: aPackage\x0a\x09super selectItem: aPackage.\x0a    self model selectedPackage: aPackage",
messageSends: ["selectItem:", "selectedPackage:", "model"],
referencedClasses: []
}),
smalltalk.HLPackagesListWidget);



smalltalk.addClass('HLProtocolsListWidget', smalltalk.HLBrowserListWidget, [], 'Helios-Browser');
smalltalk.addMethod(
"_allProtocol",
smalltalk.method({
selector: "allProtocol",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_allProtocol",[]);
return $1;
},
args: [],
source: "allProtocol\x0a\x09^ self model allProtocol",
messageSends: ["allProtocol", "model"],
referencedClasses: []
}),
smalltalk.HLProtocolsListWidget);

smalltalk.addMethod(
"_classSelected_",
smalltalk.method({
selector: "classSelected:",
category: 'actions',
fn: function (aClass){
var self=this;
var $2,$3,$1;
smalltalk.send(self,"_selectedItem_",[nil]);
if(($receiver = aClass) == nil || $receiver == undefined){
$1=smalltalk.send((smalltalk.Array || Array),"_with_",[smalltalk.send(self,"_allProtocol",[])]);
} else {
$2=smalltalk.send((smalltalk.Array || Array),"_with_",[smalltalk.send(self,"_allProtocol",[])]);
smalltalk.send($2,"_addAll_",[smalltalk.send(aClass,"_protocols",[])]);
$3=smalltalk.send($2,"_yourself",[]);
$1=$3;
};
smalltalk.send(self,"_items_",[$1]);
smalltalk.send(self,"_refresh",[]);
return self},
args: ["aClass"],
source: "classSelected: aClass\x0a    self selectedItem: nil.\x0a    \x0a    self items: (aClass\x0a    \x09ifNil: [ Array with: self allProtocol ]\x0a      \x09ifNotNil: [ \x0a        \x09(Array with: self allProtocol) \x0a            \x09addAll: aClass protocols; \x0a                yourself ]).\x0a\x0a    self refresh",
messageSends: ["selectedItem:", "items:", "ifNil:ifNotNil:", "with:", "allProtocol", "addAll:", "protocols", "yourself", "refresh"],
referencedClasses: ["Array"]
}),
smalltalk.HLProtocolsListWidget);

smalltalk.addMethod(
"_registerBindingsOn_",
smalltalk.method({
selector: "registerBindingsOn:",
category: 'keybindings',
fn: function (aBindingGroup){
var self=this;
smalltalk.send(smalltalk.send(aBindingGroup,"_at_",["Go to"]),"_addActionKey_labelled_callback_",[(84),"Protocols",(function(){
return smalltalk.send(self,"_focus",[]);
})]);
return self},
args: ["aBindingGroup"],
source: "registerBindingsOn: aBindingGroup\x0a\x09(aBindingGroup at: 'Go to') \x0a    \x09addActionKey: 84 labelled: 'Protocols' callback: [ self focus ]",
messageSends: ["addActionKey:labelled:callback:", "focus", "at:"],
referencedClasses: []
}),
smalltalk.HLProtocolsListWidget);

smalltalk.addMethod(
"_renderContentOn_",
smalltalk.method({
selector: "renderContentOn:",
category: 'rendering',
fn: function (html){
var self=this;
var $1,$2,$3;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_showInstance",[]);
if(smalltalk.assert($1)){
smalltalk.send(self,"_renderContentOn_",[html],smalltalk.HLBrowserListWidget);
} else {
$2=smalltalk.send(html,"_div",[]);
smalltalk.send($2,"_class_",["class_side"]);
$3=smalltalk.send($2,"_with_",[(function(){
return smalltalk.send(self,"_renderContentOn_",[html],smalltalk.HLBrowserListWidget);
})]);
$3;
};
return self},
args: ["html"],
source: "renderContentOn: html\x0a\x09self model showInstance\x0a    \x09ifFalse: [ html div \x0a        \x09class: 'class_side'; \x0a            with: [ super renderContentOn: html ] ]\x0a      \x09ifTrue: [ super renderContentOn: html ]",
messageSends: ["ifFalse:ifTrue:", "class:", "div", "with:", "renderContentOn:", "showInstance", "model"],
referencedClasses: []
}),
smalltalk.HLProtocolsListWidget);

smalltalk.addMethod(
"_selectItem_",
smalltalk.method({
selector: "selectItem:",
category: 'actions',
fn: function (aString){
var self=this;
smalltalk.send(self,"_selectItem_",[aString],smalltalk.HLBrowserListWidget);
smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedProtocol_",[aString]);
return self},
args: ["aString"],
source: "selectItem: aString\x0a\x09super selectItem: aString.\x0a    self model selectedProtocol: aString",
messageSends: ["selectItem:", "selectedProtocol:", "model"],
referencedClasses: []
}),
smalltalk.HLProtocolsListWidget);

smalltalk.addMethod(
"_selectedItem",
smalltalk.method({
selector: "selectedItem",
category: 'accessing',
fn: function (){
var self=this;
var $2,$1;
$2=smalltalk.send(self,"_selectedItem",[],smalltalk.HLBrowserListWidget);
if(($receiver = $2) == nil || $receiver == undefined){
$1=smalltalk.send(self,"_allProtocol",[]);
} else {
$1=$2;
};
return $1;
},
args: [],
source: "selectedItem\x0a\x09^ super selectedItem ifNil: [ self allProtocol ]",
messageSends: ["ifNil:", "allProtocol", "selectedItem"],
referencedClasses: []
}),
smalltalk.HLProtocolsListWidget);

smalltalk.addMethod(
"_subscribeTo_",
smalltalk.method({
selector: "subscribeTo:",
category: 'announcements',
fn: function (anAnnouncer){
var self=this;
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLClassSelected || HLClassSelected),(function(ann){
return smalltalk.send(self,"_classSelected_",[smalltalk.send(ann,"_item",[])]);
})]);
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLShowInstanceToggled || HLShowInstanceToggled),(function(ann){
return smalltalk.send(self,"_classSelected_",[smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[])]);
})]);
return self},
args: ["anAnnouncer"],
source: "subscribeTo: anAnnouncer\x0a\x09anAnnouncer on: HLClassSelected do: [ :ann |\x0a    \x09self classSelected: ann item ].\x0a    anAnnouncer on: HLShowInstanceToggled do: [ :ann |\x0a    \x09self classSelected: self model selectedClass ]",
messageSends: ["on:do:", "classSelected:", "item", "selectedClass", "model"],
referencedClasses: ["HLClassSelected", "HLShowInstanceToggled"]
}),
smalltalk.HLProtocolsListWidget);



smalltalk.addClass('HLBrowserModel', smalltalk.Object, ['announcer', 'environment', 'selectedPackage', 'selectedClass', 'selectedProtocol', 'selectedMethod', 'showInstance', 'showComment'], 'Helios-Browser');
smalltalk.addMethod(
"_allProtocol",
smalltalk.method({
selector: "allProtocol",
category: 'accessing',
fn: function (){
var self=this;
return "-- All --";
},
args: [],
source: "allProtocol\x0a\x09^ '-- All --'",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_announcer",
smalltalk.method({
selector: "announcer",
category: 'announcements',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@announcer"]) == nil || $receiver == undefined){
self["@announcer"]=smalltalk.send((smalltalk.Announcer || Announcer),"_new",[]);
$1=self["@announcer"];
} else {
$1=self["@announcer"];
};
return $1;
},
args: [],
source: "announcer\x0a\x09^ announcer ifNil: [ announcer := Announcer new ]",
messageSends: ["ifNil:", "new"],
referencedClasses: ["Announcer"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_environment",
smalltalk.method({
selector: "environment",
category: 'accessing',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@environment"]) == nil || $receiver == undefined){
self["@environment"]=smalltalk.send((smalltalk.Smalltalk || Smalltalk),"_current",[]);
$1=self["@environment"];
} else {
$1=self["@environment"];
};
return $1;
},
args: [],
source: "environment\x0a\x09^ environment ifNil: [ environment := Smalltalk current ]",
messageSends: ["ifNil:", "current"],
referencedClasses: ["Smalltalk"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_environment_",
smalltalk.method({
selector: "environment:",
category: 'accessing',
fn: function (anEnvironment){
var self=this;
self["@environment"]=anEnvironment;
return self},
args: ["anEnvironment"],
source: "environment: anEnvironment\x0a\x09environment := anEnvironment",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_packages",
smalltalk.method({
selector: "packages",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_environment",[]),"_packages",[]);
return $1;
},
args: [],
source: "packages\x0a\x09^ self environment packages",
messageSends: ["packages", "environment"],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedClass",
smalltalk.method({
selector: "selectedClass",
category: 'accessing',
fn: function (){
var self=this;
return self["@selectedClass"];
},
args: [],
source: "selectedClass\x0a\x09^ selectedClass",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedClass_",
smalltalk.method({
selector: "selectedClass:",
category: 'accessing',
fn: function (aClass){
var self=this;
var $1,$2;
if(($receiver = aClass) == nil || $receiver == undefined){
self["@selectedClass"]=nil;
self["@selectedClass"];
} else {
$1=smalltalk.send(self,"_showInstance",[]);
if(smalltalk.assert($1)){
self["@selectedClass"]=smalltalk.send(aClass,"_theNonMetaClass",[]);
self["@selectedClass"];
} else {
self["@selectedClass"]=smalltalk.send(aClass,"_theMetaClass",[]);
self["@selectedClass"];
};
};
smalltalk.send(self,"_selectedMethod_",[nil]);
$2=smalltalk.send(self,"_selectedProtocol_",[nil]);
smalltalk.send(smalltalk.send(self,"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLClassSelected || HLClassSelected),"_on_",[smalltalk.send(self,"_selectedClass",[])])]);
return self},
args: ["aClass"],
source: "selectedClass: aClass\x0a\x09aClass \x0a    \x09ifNil: [ selectedClass := nil ]\x0a      \x09ifNotNil: [\x0a\x09\x09\x09self showInstance \x0a    \x09\x09\x09ifTrue: [ selectedClass := aClass theNonMetaClass ]\x0a      \x09\x09\x09ifFalse: [ selectedClass := aClass theMetaClass ] ].\x0a    \x0a    self \x0a    \x09selectedMethod: nil;\x0a        selectedProtocol: nil.\x0a        \x0a   self announcer announce: (HLClassSelected on: self selectedClass)",
messageSends: ["ifNil:ifNotNil:", "ifTrue:ifFalse:", "theNonMetaClass", "theMetaClass", "showInstance", "selectedMethod:", "selectedProtocol:", "announce:", "on:", "selectedClass", "announcer"],
referencedClasses: ["HLClassSelected"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedMethod",
smalltalk.method({
selector: "selectedMethod",
category: 'accessing',
fn: function (){
var self=this;
return self["@selectedMethod"];
},
args: [],
source: "selectedMethod\x0a\x09^ selectedMethod",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedMethod_",
smalltalk.method({
selector: "selectedMethod:",
category: 'accessing',
fn: function (aCompiledMethod){
var self=this;
self["@selectedMethod"]=aCompiledMethod;
smalltalk.send(smalltalk.send(self,"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLMethodSelected || HLMethodSelected),"_on_",[aCompiledMethod])]);
return self},
args: ["aCompiledMethod"],
source: "selectedMethod: aCompiledMethod\x0a\x09selectedMethod := aCompiledMethod.\x0a    \x0a    self announcer announce: (HLMethodSelected on: aCompiledMethod)",
messageSends: ["announce:", "on:", "announcer"],
referencedClasses: ["HLMethodSelected"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedPackage",
smalltalk.method({
selector: "selectedPackage",
category: 'accessing',
fn: function (){
var self=this;
return self["@selectedPackage"];
},
args: [],
source: "selectedPackage\x0a\x09^ selectedPackage",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedPackage_",
smalltalk.method({
selector: "selectedPackage:",
category: 'accessing',
fn: function (aPackage){
var self=this;
self["@selectedPackage"]=aPackage;
smalltalk.send(self,"_selectedClass_",[nil]);
smalltalk.send(smalltalk.send(self,"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLPackageSelected || HLPackageSelected),"_on_",[aPackage])]);
return self},
args: ["aPackage"],
source: "selectedPackage: aPackage\x0a\x0a\x09selectedPackage := aPackage.\x0a    self selectedClass: nil.\x0a    \x0a    self announcer announce: (HLPackageSelected on: aPackage)",
messageSends: ["selectedClass:", "announce:", "on:", "announcer"],
referencedClasses: ["HLPackageSelected"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedProtocol",
smalltalk.method({
selector: "selectedProtocol",
category: 'accessing',
fn: function (){
var self=this;
return self["@selectedProtocol"];
},
args: [],
source: "selectedProtocol\x0a\x09^ selectedProtocol",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_selectedProtocol_",
smalltalk.method({
selector: "selectedProtocol:",
category: 'accessing',
fn: function (aString){
var self=this;
self["@selectedProtocol"]=aString;
smalltalk.send(self,"_selectedMethod_",[nil]);
smalltalk.send(smalltalk.send(self,"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLProtocolSelected || HLProtocolSelected),"_on_",[aString])]);
return self},
args: ["aString"],
source: "selectedProtocol: aString\x0a\x09selectedProtocol := aString.\x0a    \x0a    self selectedMethod: nil.\x0a    \x0a    self announcer announce: (HLProtocolSelected on: aString)",
messageSends: ["selectedMethod:", "announce:", "on:", "announcer"],
referencedClasses: ["HLProtocolSelected"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_showComment",
smalltalk.method({
selector: "showComment",
category: 'accessing',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@showComment"]) == nil || $receiver == undefined){
$1=false;
} else {
$1=self["@showComment"];
};
return $1;
},
args: [],
source: "showComment\x0a\x09^ showComment ifNil: [ false ]",
messageSends: ["ifNil:"],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_showComment_",
smalltalk.method({
selector: "showComment:",
category: 'accessing',
fn: function (aBoolean){
var self=this;
self["@showComment"]=aBoolean;
smalltalk.send(smalltalk.send(self,"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLShowCommentToggled || HLShowCommentToggled),"_new",[])]);
return self},
args: ["aBoolean"],
source: "showComment: aBoolean\x0a\x09showComment := aBoolean.\x0a    \x0a    self announcer announce: HLShowCommentToggled new",
messageSends: ["announce:", "new", "announcer"],
referencedClasses: ["HLShowCommentToggled"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_showInstance",
smalltalk.method({
selector: "showInstance",
category: 'accessing',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@showInstance"]) == nil || $receiver == undefined){
$1=true;
} else {
$1=self["@showInstance"];
};
return $1;
},
args: [],
source: "showInstance\x0a\x09^ showInstance ifNil: [ true ]",
messageSends: ["ifNil:"],
referencedClasses: []
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_showInstance_",
smalltalk.method({
selector: "showInstance:",
category: 'accessing',
fn: function (aBoolean){
var self=this;
var $1,$2;
self["@showInstance"]=aBoolean;
$1=smalltalk.send(self,"_selectedClass",[]);
if(($receiver = $1) == nil || $receiver == undefined){
$1;
} else {
if(smalltalk.assert(aBoolean)){
$2=smalltalk.send(smalltalk.send(self,"_selectedClass",[]),"_theNonMetaClass",[]);
} else {
$2=smalltalk.send(smalltalk.send(self,"_selectedClass",[]),"_theMetaClass",[]);
};
smalltalk.send(self,"_selectedClass_",[$2]);
};
smalltalk.send(smalltalk.send(self,"_announcer",[]),"_announce_",[smalltalk.send((smalltalk.HLShowInstanceToggled || HLShowInstanceToggled),"_new",[])]);
return self},
args: ["aBoolean"],
source: "showInstance: aBoolean\x0a\x09showInstance := aBoolean.\x0a    \x0a    self selectedClass ifNotNil: [\x0a    \x09self selectedClass: (aBoolean\x0a    \x09\x09ifTrue: [self selectedClass theNonMetaClass ]\x0a    \x09  \x09ifFalse: [ self selectedClass theMetaClass ]) ].\x0a    \x0a    self announcer announce: HLShowInstanceToggled new",
messageSends: ["ifNotNil:", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "selectedClass", "theMetaClass", "announce:", "new", "announcer"],
referencedClasses: ["HLShowInstanceToggled"]
}),
smalltalk.HLBrowserModel);

smalltalk.addMethod(
"_subscribe_",
smalltalk.method({
selector: "subscribe:",
category: 'announcements',
fn: function (aWidget){
var self=this;
smalltalk.send(aWidget,"_subscribeTo_",[smalltalk.send(self,"_announcer",[])]);
return self},
args: ["aWidget"],
source: "subscribe: aWidget\x0a\x09aWidget subscribeTo: self announcer",
messageSends: ["subscribeTo:", "announcer"],
referencedClasses: []
}),
smalltalk.HLBrowserModel);



smalltalk.addClass('HLBrowserSourceWidget', smalltalk.HLWidget, ['model', 'sourceArea'], 'Helios-Browser');
smalltalk.addMethod(
"_classSelected_",
smalltalk.method({
selector: "classSelected:",
category: 'actions',
fn: function (aClass){
var self=this;
var $1;
if(($receiver = aClass) == nil || $receiver == undefined){
$1=smalltalk.send(self,"_contents_",[""]);
return $1;
} else {
aClass;
};
smalltalk.send(self,"_contents_",[smalltalk.send(aClass,"_definition",[])]);
return self},
args: ["aClass"],
source: "classSelected: aClass\x0a\x09aClass ifNil: [ ^ self contents: '' ].\x0a    \x0a    self contents: aClass definition",
messageSends: ["ifNil:", "contents:", "definition"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_contents",
smalltalk.method({
selector: "contents",
category: 'accessing',
fn: function (){
var self=this;
var $1;
$1=smalltalk.send(smalltalk.send(self,"_sourceArea",[]),"_contents",[]);
return $1;
},
args: [],
source: "contents\x0a\x09^ self sourceArea contents",
messageSends: ["contents", "sourceArea"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_contents_",
smalltalk.method({
selector: "contents:",
category: 'accessing',
fn: function (aString){
var self=this;
smalltalk.send(smalltalk.send(self,"_sourceArea",[]),"_contents_",[aString]);
return self},
args: ["aString"],
source: "contents: aString\x0a\x09self sourceArea contents: aString",
messageSends: ["contents:", "sourceArea"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_methodSelected_",
smalltalk.method({
selector: "methodSelected:",
category: 'actions',
fn: function (aCompiledMethod){
var self=this;
var $1;
if(($receiver = aCompiledMethod) == nil || $receiver == undefined){
$1=smalltalk.send(self,"_contents_",[""]);
return $1;
} else {
aCompiledMethod;
};
smalltalk.send(self,"_contents_",[smalltalk.send(aCompiledMethod,"_source",[])]);
return self},
args: ["aCompiledMethod"],
source: "methodSelected: aCompiledMethod\x0a\x09aCompiledMethod ifNil: [ ^ self contents: '' ].\x0a    \x0a    self contents: aCompiledMethod source",
messageSends: ["ifNil:", "contents:", "source"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_model",
smalltalk.method({
selector: "model",
category: 'accessing',
fn: function (){
var self=this;
return self["@model"];
},
args: [],
source: "model\x0a\x09^ model",
messageSends: [],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_model_",
smalltalk.method({
selector: "model:",
category: 'accessing',
fn: function (aBrowserModel){
var self=this;
self["@model"]=aBrowserModel;
smalltalk.send(self["@model"],"_subscribe_",[self]);
return self},
args: ["aBrowserModel"],
source: "model: aBrowserModel\x0a\x09\x22TODO: unsubscribe from previous model\x22\x0a    \x0a\x09model := aBrowserModel.\x0a    model subscribe: self",
messageSends: ["subscribe:"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_protocolSelected_",
smalltalk.method({
selector: "protocolSelected:",
category: 'actions',
fn: function (aString){
var self=this;
var $1,$2;
$1=smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]);
if(($receiver = $1) == nil || $receiver == undefined){
$2=smalltalk.send(self,"_contents_",[""]);
return $2;
} else {
$1;
};
smalltalk.send(self,"_contents_",[smalltalk.send(smalltalk.send(smalltalk.send(self,"_model",[]),"_selectedClass",[]),"_definition",[])]);
return self},
args: ["aString"],
source: "protocolSelected: aString\x0a\x09self model selectedClass ifNil: [ ^ self contents: '' ].\x0a    \x0a    self contents: self model selectedClass definition",
messageSends: ["ifNil:", "contents:", "selectedClass", "model", "definition"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_renderContentOn_",
smalltalk.method({
selector: "renderContentOn:",
category: 'rendering',
fn: function (html){
var self=this;
smalltalk.send(smalltalk.send(self,"_sourceArea",[]),"_renderOn_",[html]);
return self},
args: ["html"],
source: "renderContentOn: html\x0a\x09self sourceArea renderOn: html",
messageSends: ["renderOn:", "sourceArea"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_sourceArea",
smalltalk.method({
selector: "sourceArea",
category: 'accessing',
fn: function (){
var self=this;
var $1;
if(($receiver = self["@sourceArea"]) == nil || $receiver == undefined){
self["@sourceArea"]=smalltalk.send((smalltalk.HLSourceArea || HLSourceArea),"_new",[]);
$1=self["@sourceArea"];
} else {
$1=self["@sourceArea"];
};
return $1;
},
args: [],
source: "sourceArea\x0a\x09^ sourceArea ifNil: [ sourceArea := HLSourceArea new ]",
messageSends: ["ifNil:", "new"],
referencedClasses: ["HLSourceArea"]
}),
smalltalk.HLBrowserSourceWidget);

smalltalk.addMethod(
"_subscribeTo_",
smalltalk.method({
selector: "subscribeTo:",
category: 'announcements',
fn: function (anAnnouncer){
var self=this;
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLMethodSelected || HLMethodSelected),(function(ann){
return smalltalk.send(self,"_methodSelected_",[smalltalk.send(ann,"_item",[])]);
})]);
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLClassSelected || HLClassSelected),(function(ann){
return smalltalk.send(self,"_classSelected_",[smalltalk.send(ann,"_item",[])]);
})]);
smalltalk.send(anAnnouncer,"_on_do_",[(smalltalk.HLProtocolSelected || HLProtocolSelected),(function(ann){
return smalltalk.send(self,"_protocolSelected_",[smalltalk.send(ann,"_item",[])]);
})]);
return self},
args: ["anAnnouncer"],
source: "subscribeTo: anAnnouncer\x0a\x09anAnnouncer on: HLMethodSelected do: [ :ann |\x0a    \x09self methodSelected: ann item ].\x0a    anAnnouncer on: HLClassSelected do: [ :ann |\x0a    \x09self classSelected: ann item ].\x0a    anAnnouncer on: HLProtocolSelected do: [ :ann |\x0a    \x09self protocolSelected: ann item ]",
messageSends: ["on:do:", "methodSelected:", "item", "classSelected:", "protocolSelected:"],
referencedClasses: ["HLMethodSelected", "HLClassSelected", "HLProtocolSelected"]
}),
smalltalk.HLBrowserSourceWidget);


smalltalk.addMethod(
"_on_",
smalltalk.method({
selector: "on:",
category: 'instance creation',
fn: function (aBrowserModel){
var self=this;
var $2,$3,$1;
$2=smalltalk.send(self,"_new",[]);
smalltalk.send($2,"_model_",[aBrowserModel]);
$3=smalltalk.send($2,"_yourself",[]);
$1=$3;
return $1;
},
args: ["aBrowserModel"],
source: "on: aBrowserModel\x0a\x09^ self new\x0a    \x09model: aBrowserModel;\x0a        yourself",
messageSends: ["model:", "new", "yourself"],
referencedClasses: []
}),
smalltalk.HLBrowserSourceWidget.klass);