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