helios/src/Helios-Commands-Browser.js

define(["amber/boot", "helios/Helios-Commands-Tools"], function($boot){"use strict";
if(!$boot.nilAsReceiver)$boot.nilAsReceiver=$boot.nil;
if(!("nilAsValue" in $boot))$boot.nilAsValue=$boot.nilAsReceiver;
var $core=$boot.api,nil=$boot.nilAsValue,$nil=$boot.nilAsReceiver,$recv=$boot.asReceiver,$globals=$boot.globals;
if(!$boot.nilAsClass)$boot.nilAsClass=$boot.dnu;
$core.addPackage("Helios-Commands-Browser");
$core.packages["Helios-Commands-Browser"].innerEval = function (expr) { return eval(expr); };
$core.packages["Helios-Commands-Browser"].transport = {"type":"amd","amdNamespace":"helios"};

$core.addClass("HLBrowserCommand", $globals.HLToolCommand, [], "Helios-Commands-Browser");

$core.addMethod(
$core.method({
selector: "isValidFor:",
protocol: "testing",
fn: function (aModel){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv(aModel)._isBrowserModel();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLBrowserCommand.a$cls)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aModel"],
source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["isBrowserModel"]
}),
$globals.HLBrowserCommand.a$cls);


$core.addClass("HLBrowserGoToCommand", $globals.HLBrowserCommand, [], "Helios-Commands-Browser");

$core.addMethod(
$core.method({
selector: "isValidFor:",
protocol: "testing",
fn: function (aModel){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv(aModel)._isBrowserModel();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLBrowserGoToCommand.a$cls)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aModel"],
source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["isBrowserModel"]
}),
$globals.HLBrowserGoToCommand.a$cls);

$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "g";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'g'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLBrowserGoToCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Go to";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Go to'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLBrowserGoToCommand.a$cls);


$core.addClass("HLGoToClassesCommand", $globals.HLBrowserGoToCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._focusOnClasses();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToClassesCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model focusOnClasses",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["focusOnClasses", "model"]
}),
$globals.HLGoToClassesCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "c";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'c'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToClassesCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Classes";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Classes'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToClassesCommand.a$cls);


$core.addClass("HLGoToDocumentationCommand", $globals.HLBrowserGoToCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._focusOnDocumentation();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToDocumentationCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model focusOnDocumentation",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["focusOnDocumentation", "model"]
}),
$globals.HLGoToDocumentationCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "d";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'd'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToDocumentationCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Documentation";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Documentation'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToDocumentationCommand.a$cls);


$core.addClass("HLGoToMethodsCommand", $globals.HLBrowserGoToCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._focusOnMethods();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToMethodsCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model focusOnMethods",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["focusOnMethods", "model"]
}),
$globals.HLGoToMethodsCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "m";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'm'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToMethodsCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Methods";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Methods'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToMethodsCommand.a$cls);


$core.addClass("HLGoToPackagesCommand", $globals.HLBrowserGoToCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._focusOnPackages();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToPackagesCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model focusOnPackages",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["focusOnPackages", "model"]
}),
$globals.HLGoToPackagesCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "p";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'p'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToPackagesCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Packages";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Packages'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToPackagesCommand.a$cls);


$core.addClass("HLGoToProtocolsCommand", $globals.HLBrowserGoToCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._focusOnProtocols();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToProtocolsCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model focusOnProtocols",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["focusOnProtocols", "model"]
}),
$globals.HLGoToProtocolsCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "t";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 't'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToProtocolsCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Protocols";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Protocols'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToProtocolsCommand.a$cls);


$core.addClass("HLGoToSourceCodeCommand", $globals.HLBrowserGoToCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._focusOnSourceCode();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToSourceCodeCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model focusOnSourceCode",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["focusOnSourceCode", "model"]
}),
$globals.HLGoToSourceCodeCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "s";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 's'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToSourceCodeCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Source code";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Source code'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGoToSourceCodeCommand.a$cls);


$core.addClass("HLEditCommentCommand", $globals.HLBrowserCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._model())._editComment();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLEditCommentCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model editComment",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["editComment", "model"]
}),
$globals.HLEditCommentCommand);

$core.addMethod(
$core.method({
selector: "isActive",
protocol: "testing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $2,$1;
$2=$self._model();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["model"]=1;
//>>excludeEnd("ctx");
$1=$recv($2)._showComment();
return $recv($1)._and_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($recv($self._model())._selectedClass())._notNil();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLEditCommentCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "isActive\x0a\x09^ self model showComment and: [ self model selectedClass notNil ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["and:", "showComment", "model", "notNil", "selectedClass"]
}),
$globals.HLEditCommentCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "d";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'd'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLEditCommentCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Edit documentation";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Edit documentation'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLEditCommentCommand.a$cls);


$core.addClass("HLGenerateCommand", $globals.HLBrowserCommand, [], "Helios-Commands-Browser");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLGenerateCommand.comment="I am a group command used to gather all the commands generating code (`accessors`, `initialize`, etc)";
//>>excludeEnd("ide");

$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "h";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'h'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGenerateCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Generate";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Generate'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGenerateCommand.a$cls);


$core.addClass("HLCategorizeUnclassifiedCommand", $globals.HLGenerateCommand, [], "Helios-Commands-Browser");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLCategorizeUnclassifiedCommand.comment="I am the command used to categorize unclassified methods";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
var targetClass,unclassified;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
targetClass=$recv($self._model())._selectedClass();
unclassified=$recv($recv(targetClass)._methods())._select_((function(e){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($recv(e)._protocol()).__eq("as yet unclassified");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)});
//>>excludeEnd("ctx");
}));
$recv($recv($globals.HLMethodClassifier)._new())._classifyAll_(unclassified);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,unclassified:unclassified},$globals.HLCategorizeUnclassifiedCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
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",
referencedClasses: ["HLMethodClassifier"],
//>>excludeEnd("ide");
messageSends: ["selectedClass", "model", "select:", "methods", "=", "protocol", "classifyAll:", "new"]
}),
$globals.HLCategorizeUnclassifiedCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "c";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'c'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLCategorizeUnclassifiedCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Categorize";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Categorize'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLCategorizeUnclassifiedCommand.a$cls);


$core.addClass("HLGenerateAccessorsCommand", $globals.HLGenerateCommand, [], "Helios-Commands-Browser");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLGenerateAccessorsCommand.comment="I am the command used to generate the `getter` and the `setter` methods depending of the selected class";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
var targetClass,output,first;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2,$3;
$1=$self._model();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["model"]=1;
//>>excludeEnd("ctx");
targetClass=$recv($1)._selectedClass();
$2=$recv($globals.HLInitializeGenerator)._new();
$recv($2)._class_(targetClass);
$recv($2)._generate();
output=$recv($2)._output();
$recv(output)._compile();
first=$recv($recv(output)._sourceCodes())._first();
$3=$self._model();
$recv($3)._selectedProtocol_($recv(output)._protocol());
$recv($3)._selectedMethod_($recv(targetClass).__gt_gt($recv(first)._selector()));
$recv($3)._focusOnSourceCode();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output,first:first},$globals.HLGenerateAccessorsCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
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",
referencedClasses: ["HLInitializeGenerator"],
//>>excludeEnd("ide");
messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "first", "sourceCodes", "selectedProtocol:", "protocol", "selectedMethod:", ">>", "selector", "focusOnSourceCode"]
}),
$globals.HLGenerateAccessorsCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "i";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'i'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGenerateAccessorsCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Initialize";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Initialize'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGenerateAccessorsCommand.a$cls);


$core.addClass("HLGenerateInitializeCommand", $globals.HLGenerateCommand, [], "Helios-Commands-Browser");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HLGenerateInitializeCommand.comment="I am the command used to generate the `initialize` method depending of the selected class";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
var targetClass,output;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=$self._model();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["model"]=1;
//>>excludeEnd("ctx");
targetClass=$recv($1)._selectedClass();
$2=$recv($globals.HLAccessorsGenerator)._new();
$recv($2)._class_(targetClass);
$recv($2)._generate();
output=$recv($2)._output();
$recv(output)._compile();
$recv($self._model())._selectedProtocol_($recv(output)._protocol());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output},$globals.HLGenerateInitializeCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
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",
referencedClasses: ["HLAccessorsGenerator"],
//>>excludeEnd("ide");
messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "selectedProtocol:", "protocol"]
}),
$globals.HLGenerateInitializeCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "a";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'a'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGenerateInitializeCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Accessors";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Accessors'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLGenerateInitializeCommand.a$cls);


$core.addClass("HLToggleCommand", $globals.HLBrowserCommand, [], "Helios-Commands-Browser");

$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "t";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 't'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLToggleCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Toggle";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Toggle'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLToggleCommand.a$cls);


$core.addClass("HLToggleClassCommentCommand", $globals.HLToggleCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self._model();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["model"]=1;
//>>excludeEnd("ctx");
$recv($1)._showComment_($recv($recv($self._model())._showComment())._not());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLToggleClassCommentCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model showComment: self model showComment not",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["showComment:", "model", "not", "showComment"]
}),
$globals.HLToggleClassCommentCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "d";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'd'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLToggleClassCommentCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Documentation";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Documentation'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLToggleClassCommentCommand.a$cls);


$core.addClass("HLToggleClassSideCommand", $globals.HLToggleCommand, [], "Helios-Commands-Browser");
$core.addMethod(
$core.method({
selector: "execute",
protocol: "executing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self._model();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["model"]=1;
//>>excludeEnd("ctx");
$recv($1)._showInstance_($recv($recv($self._model())._showInstance())._not());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLToggleClassSideCommand)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "execute\x0a\x09self model showInstance: self model showInstance not",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["showInstance:", "model", "not", "showInstance"]
}),
$globals.HLToggleClassSideCommand);


$core.addMethod(
$core.method({
selector: "key",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "c";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "key\x0a\x09^ 'c'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLToggleClassSideCommand.a$cls);

$core.addMethod(
$core.method({
selector: "label",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "Class side";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ 'Class side'",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.HLToggleClassSideCommand.a$cls);

});