2
0

Helios-Commands-Tools.js 40 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827
  1. define("amber_core/Helios-Commands-Tools", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Helios-Commands-Core"], function(smalltalk,nil,_st, globals){
  2. smalltalk.addPackage('Helios-Commands-Tools');
  3. smalltalk.packages["Helios-Commands-Tools"].transport = {"type":"amd","amdNamespace":"amber_core"};
  4. smalltalk.addClass('HLToolCommand', globals.HLModelCommand, [], 'Helios-Commands-Tools');
  5. smalltalk.addMethod(
  6. smalltalk.method({
  7. selector: "category",
  8. protocol: 'accessing',
  9. fn: function (){
  10. var self=this;
  11. return nil;
  12. },
  13. args: [],
  14. source: "category\x0a\x09^ nil",
  15. messageSends: [],
  16. referencedClasses: []
  17. }),
  18. globals.HLToolCommand);
  19. smalltalk.addMethod(
  20. smalltalk.method({
  21. selector: "for:",
  22. protocol: 'instance creation',
  23. fn: function (aToolModel){
  24. var self=this;
  25. return smalltalk.withContext(function($ctx1) {
  26. var $2,$3,$1;
  27. $2=self._new();
  28. _st($2)._model_(aToolModel);
  29. $3=_st($2)._yourself();
  30. $1=$3;
  31. return $1;
  32. }, function($ctx1) {$ctx1.fill(self,"for:",{aToolModel:aToolModel},globals.HLToolCommand.klass)})},
  33. args: ["aToolModel"],
  34. source: "for: aToolModel\x0a\x09^ self new\x0a \x09model: aToolModel;\x0a yourself",
  35. messageSends: ["model:", "new", "yourself"],
  36. referencedClasses: []
  37. }),
  38. globals.HLToolCommand.klass);
  39. smalltalk.addMethod(
  40. smalltalk.method({
  41. selector: "isValidFor:",
  42. protocol: 'testing',
  43. fn: function (aModel){
  44. var self=this;
  45. return smalltalk.withContext(function($ctx1) {
  46. var $1;
  47. $1=_st(aModel)._isToolModel();
  48. return $1;
  49. }, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLToolCommand.klass)})},
  50. args: ["aModel"],
  51. source: "isValidFor: aModel\x0a\x09^ aModel isToolModel",
  52. messageSends: ["isToolModel"],
  53. referencedClasses: []
  54. }),
  55. globals.HLToolCommand.klass);
  56. smalltalk.addClass('HLCommitPackageCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
  57. smalltalk.addMethod(
  58. smalltalk.method({
  59. selector: "category",
  60. protocol: 'accessing',
  61. fn: function (){
  62. var self=this;
  63. return "Packages";
  64. },
  65. args: [],
  66. source: "category\x0a\x09^ 'Packages'",
  67. messageSends: [],
  68. referencedClasses: []
  69. }),
  70. globals.HLCommitPackageCommand);
  71. smalltalk.addMethod(
  72. smalltalk.method({
  73. selector: "execute",
  74. protocol: 'executing',
  75. fn: function (){
  76. var self=this;
  77. return smalltalk.withContext(function($ctx1) {
  78. _st(self._model())._commitPackage();
  79. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCommitPackageCommand)})},
  80. args: [],
  81. source: "execute\x0a\x09self model commitPackage",
  82. messageSends: ["commitPackage", "model"],
  83. referencedClasses: []
  84. }),
  85. globals.HLCommitPackageCommand);
  86. smalltalk.addMethod(
  87. smalltalk.method({
  88. selector: "isActive",
  89. protocol: 'testing',
  90. fn: function (){
  91. var self=this;
  92. return true;
  93. },
  94. args: [],
  95. source: "isActive\x0a\x09^ true\x0a\x09\x22 slf model isPackageDirty\x22",
  96. messageSends: [],
  97. referencedClasses: []
  98. }),
  99. globals.HLCommitPackageCommand);
  100. smalltalk.addMethod(
  101. smalltalk.method({
  102. selector: "key",
  103. protocol: 'accessing',
  104. fn: function (){
  105. var self=this;
  106. return "k";
  107. },
  108. args: [],
  109. source: "key\x0a\x09^ 'k'",
  110. messageSends: [],
  111. referencedClasses: []
  112. }),
  113. globals.HLCommitPackageCommand.klass);
  114. smalltalk.addMethod(
  115. smalltalk.method({
  116. selector: "label",
  117. protocol: 'accessing',
  118. fn: function (){
  119. var self=this;
  120. return "Commit";
  121. },
  122. args: [],
  123. source: "label\x0a\x09^ 'Commit'",
  124. messageSends: [],
  125. referencedClasses: []
  126. }),
  127. globals.HLCommitPackageCommand.klass);
  128. smalltalk.addClass('HLCopyCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
  129. smalltalk.addMethod(
  130. smalltalk.method({
  131. selector: "key",
  132. protocol: 'accessing',
  133. fn: function (){
  134. var self=this;
  135. return "c";
  136. },
  137. args: [],
  138. source: "key\x0a\x09^ 'c'",
  139. messageSends: [],
  140. referencedClasses: []
  141. }),
  142. globals.HLCopyCommand.klass);
  143. smalltalk.addMethod(
  144. smalltalk.method({
  145. selector: "label",
  146. protocol: 'accessing',
  147. fn: function (){
  148. var self=this;
  149. return "Copy";
  150. },
  151. args: [],
  152. source: "label\x0a\x09^ 'Copy'",
  153. messageSends: [],
  154. referencedClasses: []
  155. }),
  156. globals.HLCopyCommand.klass);
  157. smalltalk.addClass('HLCopyClassCommand', globals.HLCopyCommand, [], 'Helios-Commands-Tools');
  158. smalltalk.addMethod(
  159. smalltalk.method({
  160. selector: "category",
  161. protocol: 'accessing',
  162. fn: function (){
  163. var self=this;
  164. return "Classes";
  165. },
  166. args: [],
  167. source: "category\x0a\x09^ 'Classes'",
  168. messageSends: [],
  169. referencedClasses: []
  170. }),
  171. globals.HLCopyClassCommand);
  172. smalltalk.addMethod(
  173. smalltalk.method({
  174. selector: "defaultInput",
  175. protocol: 'defaults',
  176. fn: function (){
  177. var self=this;
  178. return smalltalk.withContext(function($ctx1) {
  179. var $1;
  180. $1=_st(_st(self._model())._selectedClass())._name();
  181. return $1;
  182. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLCopyClassCommand)})},
  183. args: [],
  184. source: "defaultInput\x0a\x09^ self model selectedClass name",
  185. messageSends: ["name", "selectedClass", "model"],
  186. referencedClasses: []
  187. }),
  188. globals.HLCopyClassCommand);
  189. smalltalk.addMethod(
  190. smalltalk.method({
  191. selector: "displayLabel",
  192. protocol: 'accessing',
  193. fn: function (){
  194. var self=this;
  195. return "New class name:";
  196. },
  197. args: [],
  198. source: "displayLabel\x0a\x09^ 'New class name:'",
  199. messageSends: [],
  200. referencedClasses: []
  201. }),
  202. globals.HLCopyClassCommand);
  203. smalltalk.addMethod(
  204. smalltalk.method({
  205. selector: "execute",
  206. protocol: 'executing',
  207. fn: function (){
  208. var self=this;
  209. return smalltalk.withContext(function($ctx1) {
  210. _st(self._model())._copyClassTo_(self._input());
  211. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCopyClassCommand)})},
  212. args: [],
  213. source: "execute\x0a\x09self model copyClassTo: self input",
  214. messageSends: ["copyClassTo:", "model", "input"],
  215. referencedClasses: []
  216. }),
  217. globals.HLCopyClassCommand);
  218. smalltalk.addMethod(
  219. smalltalk.method({
  220. selector: "isActive",
  221. protocol: 'testing',
  222. fn: function (){
  223. var self=this;
  224. return smalltalk.withContext(function($ctx1) {
  225. var $1;
  226. $1=_st(_st(self._model())._selectedClass())._notNil();
  227. return $1;
  228. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLCopyClassCommand)})},
  229. args: [],
  230. source: "isActive\x0a\x09^ self model selectedClass notNil",
  231. messageSends: ["notNil", "selectedClass", "model"],
  232. referencedClasses: []
  233. }),
  234. globals.HLCopyClassCommand);
  235. smalltalk.addMethod(
  236. smalltalk.method({
  237. selector: "isInputRequired",
  238. protocol: 'testing',
  239. fn: function (){
  240. var self=this;
  241. return true;
  242. },
  243. args: [],
  244. source: "isInputRequired\x0a\x09^ true",
  245. messageSends: [],
  246. referencedClasses: []
  247. }),
  248. globals.HLCopyClassCommand);
  249. smalltalk.addMethod(
  250. smalltalk.method({
  251. selector: "key",
  252. protocol: 'accessing',
  253. fn: function (){
  254. var self=this;
  255. return "c";
  256. },
  257. args: [],
  258. source: "key\x0a\x09^ 'c'",
  259. messageSends: [],
  260. referencedClasses: []
  261. }),
  262. globals.HLCopyClassCommand.klass);
  263. smalltalk.addMethod(
  264. smalltalk.method({
  265. selector: "label",
  266. protocol: 'accessing',
  267. fn: function (){
  268. var self=this;
  269. return "Class";
  270. },
  271. args: [],
  272. source: "label\x0a\x09^ 'Class'",
  273. messageSends: [],
  274. referencedClasses: []
  275. }),
  276. globals.HLCopyClassCommand.klass);
  277. smalltalk.addMethod(
  278. smalltalk.method({
  279. selector: "menuLabel",
  280. protocol: 'accessing',
  281. fn: function (){
  282. var self=this;
  283. return "Copy class...";
  284. },
  285. args: [],
  286. source: "menuLabel\x0a\x09^ 'Copy class...'",
  287. messageSends: [],
  288. referencedClasses: []
  289. }),
  290. globals.HLCopyClassCommand.klass);
  291. smalltalk.addClass('HLFindCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
  292. smalltalk.addMethod(
  293. smalltalk.method({
  294. selector: "key",
  295. protocol: 'accessing',
  296. fn: function (){
  297. var self=this;
  298. return "f";
  299. },
  300. args: [],
  301. source: "key\x0a\x09^ 'f'",
  302. messageSends: [],
  303. referencedClasses: []
  304. }),
  305. globals.HLFindCommand.klass);
  306. smalltalk.addMethod(
  307. smalltalk.method({
  308. selector: "label",
  309. protocol: 'accessing',
  310. fn: function (){
  311. var self=this;
  312. return "Find";
  313. },
  314. args: [],
  315. source: "label\x0a\x09^ 'Find'",
  316. messageSends: [],
  317. referencedClasses: []
  318. }),
  319. globals.HLFindCommand.klass);
  320. smalltalk.addClass('HLFindClassCommand', globals.HLFindCommand, [], 'Helios-Commands-Tools');
  321. smalltalk.addMethod(
  322. smalltalk.method({
  323. selector: "displayLabel",
  324. protocol: 'accessing',
  325. fn: function (){
  326. var self=this;
  327. return "select a class";
  328. },
  329. args: [],
  330. source: "displayLabel\x0a\x09^ 'select a class'",
  331. messageSends: [],
  332. referencedClasses: []
  333. }),
  334. globals.HLFindClassCommand);
  335. smalltalk.addMethod(
  336. smalltalk.method({
  337. selector: "execute",
  338. protocol: 'executing',
  339. fn: function (){
  340. var self=this;
  341. return smalltalk.withContext(function($ctx1) {
  342. _st(self._model())._openClassNamed_(self._input());
  343. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLFindClassCommand)})},
  344. args: [],
  345. source: "execute\x0a\x09self model openClassNamed: self input",
  346. messageSends: ["openClassNamed:", "model", "input"],
  347. referencedClasses: []
  348. }),
  349. globals.HLFindClassCommand);
  350. smalltalk.addMethod(
  351. smalltalk.method({
  352. selector: "inputCompletion",
  353. protocol: 'accessing',
  354. fn: function (){
  355. var self=this;
  356. return smalltalk.withContext(function($ctx1) {
  357. var $1;
  358. $1=_st(self._model())._availableClassNames();
  359. return $1;
  360. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLFindClassCommand)})},
  361. args: [],
  362. source: "inputCompletion\x0a\x09^ self model availableClassNames",
  363. messageSends: ["availableClassNames", "model"],
  364. referencedClasses: []
  365. }),
  366. globals.HLFindClassCommand);
  367. smalltalk.addMethod(
  368. smalltalk.method({
  369. selector: "inputLabel",
  370. protocol: 'accessing',
  371. fn: function (){
  372. var self=this;
  373. return "Find a class";
  374. },
  375. args: [],
  376. source: "inputLabel\x0a\x09^ 'Find a class'",
  377. messageSends: [],
  378. referencedClasses: []
  379. }),
  380. globals.HLFindClassCommand);
  381. smalltalk.addMethod(
  382. smalltalk.method({
  383. selector: "isInputRequired",
  384. protocol: 'testing',
  385. fn: function (){
  386. var self=this;
  387. return true;
  388. },
  389. args: [],
  390. source: "isInputRequired\x0a\x09^ true",
  391. messageSends: [],
  392. referencedClasses: []
  393. }),
  394. globals.HLFindClassCommand);
  395. smalltalk.addMethod(
  396. smalltalk.method({
  397. selector: "isValidFor:",
  398. protocol: 'testing',
  399. fn: function (aModel){
  400. var self=this;
  401. return smalltalk.withContext(function($ctx1) {
  402. var $1;
  403. $1=_st(aModel)._isBrowserModel();
  404. return $1;
  405. }, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLFindClassCommand.klass)})},
  406. args: ["aModel"],
  407. source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
  408. messageSends: ["isBrowserModel"],
  409. referencedClasses: []
  410. }),
  411. globals.HLFindClassCommand.klass);
  412. smalltalk.addMethod(
  413. smalltalk.method({
  414. selector: "key",
  415. protocol: 'accessing',
  416. fn: function (){
  417. var self=this;
  418. return "c";
  419. },
  420. args: [],
  421. source: "key\x0a\x09^ 'c'",
  422. messageSends: [],
  423. referencedClasses: []
  424. }),
  425. globals.HLFindClassCommand.klass);
  426. smalltalk.addMethod(
  427. smalltalk.method({
  428. selector: "label",
  429. protocol: 'accessing',
  430. fn: function (){
  431. var self=this;
  432. return "Class";
  433. },
  434. args: [],
  435. source: "label\x0a\x09^ 'Class'",
  436. messageSends: [],
  437. referencedClasses: []
  438. }),
  439. globals.HLFindClassCommand.klass);
  440. smalltalk.addClass('HLFindReferencesCommand', globals.HLFindCommand, [], 'Helios-Commands-Tools');
  441. smalltalk.addMethod(
  442. smalltalk.method({
  443. selector: "defaultInput",
  444. protocol: 'defaults',
  445. fn: function (){
  446. var self=this;
  447. return smalltalk.withContext(function($ctx1) {
  448. var $3,$2,$4,$1;
  449. $3=self._model();
  450. $ctx1.sendIdx["model"]=1;
  451. $2=_st($3)._selectedMethod();
  452. if(($receiver = $2) == nil || $receiver == null){
  453. $4=_st(self._model())._selectedClass();
  454. if(($receiver = $4) == nil || $receiver == null){
  455. $1="";
  456. } else {
  457. var class_;
  458. class_=$receiver;
  459. $1=_st(class_)._name();
  460. };
  461. } else {
  462. var method;
  463. method=$receiver;
  464. $1=_st(method)._selector();
  465. };
  466. return $1;
  467. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLFindReferencesCommand)})},
  468. args: [],
  469. 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 name ] ]\x0a\x09\x09ifNotNil: [ :method | method selector ]",
  470. messageSends: ["ifNil:ifNotNil:", "selectedMethod", "model", "selectedClass", "name", "selector"],
  471. referencedClasses: []
  472. }),
  473. globals.HLFindReferencesCommand);
  474. smalltalk.addMethod(
  475. smalltalk.method({
  476. selector: "displayLabel",
  477. protocol: 'accessing',
  478. fn: function (){
  479. var self=this;
  480. return "find references";
  481. },
  482. args: [],
  483. source: "displayLabel\x0a\x09^ 'find references'",
  484. messageSends: [],
  485. referencedClasses: []
  486. }),
  487. globals.HLFindReferencesCommand);
  488. smalltalk.addMethod(
  489. smalltalk.method({
  490. selector: "execute",
  491. protocol: 'executing',
  492. fn: function (){
  493. var self=this;
  494. function $HLReferences(){return globals.HLReferences||(typeof HLReferences=="undefined"?nil:HLReferences)}
  495. return smalltalk.withContext(function($ctx1) {
  496. var $1,$2;
  497. $1=_st($HLReferences())._new();
  498. _st($1)._openAsTab();
  499. $2=_st($1)._search_(self._input());
  500. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLFindReferencesCommand)})},
  501. args: [],
  502. source: "execute\x0a\x09HLReferences new \x0a\x09\x09openAsTab;\x0a\x09\x09search: self input",
  503. messageSends: ["openAsTab", "new", "search:", "input"],
  504. referencedClasses: ["HLReferences"]
  505. }),
  506. globals.HLFindReferencesCommand);
  507. smalltalk.addMethod(
  508. smalltalk.method({
  509. selector: "inputCompletion",
  510. protocol: 'accessing',
  511. fn: function (){
  512. var self=this;
  513. return smalltalk.withContext(function($ctx1) {
  514. var $3,$2,$1;
  515. $3=self._model();
  516. $ctx1.sendIdx["model"]=1;
  517. $2=_st($3)._availableClassNames();
  518. $1=_st($2).__comma(_st(self._model())._allSelectors());
  519. return $1;
  520. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLFindReferencesCommand)})},
  521. args: [],
  522. source: "inputCompletion\x0a\x09^ self model availableClassNames, self model allSelectors",
  523. messageSends: [",", "availableClassNames", "model", "allSelectors"],
  524. referencedClasses: []
  525. }),
  526. globals.HLFindReferencesCommand);
  527. smalltalk.addMethod(
  528. smalltalk.method({
  529. selector: "inputLabel",
  530. protocol: 'accessing',
  531. fn: function (){
  532. var self=this;
  533. return "Find references of";
  534. },
  535. args: [],
  536. source: "inputLabel\x0a\x09^ 'Find references of'",
  537. messageSends: [],
  538. referencedClasses: []
  539. }),
  540. globals.HLFindReferencesCommand);
  541. smalltalk.addMethod(
  542. smalltalk.method({
  543. selector: "isInputRequired",
  544. protocol: 'testing',
  545. fn: function (){
  546. var self=this;
  547. return true;
  548. },
  549. args: [],
  550. source: "isInputRequired\x0a\x09^ true",
  551. messageSends: [],
  552. referencedClasses: []
  553. }),
  554. globals.HLFindReferencesCommand);
  555. smalltalk.addMethod(
  556. smalltalk.method({
  557. selector: "key",
  558. protocol: 'accessing',
  559. fn: function (){
  560. var self=this;
  561. return "r";
  562. },
  563. args: [],
  564. source: "key\x0a\x09^ 'r'",
  565. messageSends: [],
  566. referencedClasses: []
  567. }),
  568. globals.HLFindReferencesCommand.klass);
  569. smalltalk.addMethod(
  570. smalltalk.method({
  571. selector: "label",
  572. protocol: 'accessing',
  573. fn: function (){
  574. var self=this;
  575. return "References";
  576. },
  577. args: [],
  578. source: "label\x0a\x09^ 'References'",
  579. messageSends: [],
  580. referencedClasses: []
  581. }),
  582. globals.HLFindReferencesCommand.klass);
  583. smalltalk.addClass('HLMoveToCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
  584. smalltalk.addMethod(
  585. smalltalk.method({
  586. selector: "key",
  587. protocol: 'accessing',
  588. fn: function (){
  589. var self=this;
  590. return "m";
  591. },
  592. args: [],
  593. source: "key\x0a\x09^ 'm'",
  594. messageSends: [],
  595. referencedClasses: []
  596. }),
  597. globals.HLMoveToCommand.klass);
  598. smalltalk.addMethod(
  599. smalltalk.method({
  600. selector: "label",
  601. protocol: 'accessing',
  602. fn: function (){
  603. var self=this;
  604. return "Move";
  605. },
  606. args: [],
  607. source: "label\x0a\x09^ 'Move'",
  608. messageSends: [],
  609. referencedClasses: []
  610. }),
  611. globals.HLMoveToCommand.klass);
  612. smalltalk.addClass('HLMoveClassToCommand', globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
  613. smalltalk.addMethod(
  614. smalltalk.method({
  615. selector: "isActive",
  616. protocol: 'testing',
  617. fn: function (){
  618. var self=this;
  619. return smalltalk.withContext(function($ctx1) {
  620. var $1;
  621. $1=_st(_st(self._model())._selectedClass())._notNil();
  622. return $1;
  623. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLMoveClassToCommand)})},
  624. args: [],
  625. source: "isActive\x0a\x09^ self model selectedClass notNil",
  626. messageSends: ["notNil", "selectedClass", "model"],
  627. referencedClasses: []
  628. }),
  629. globals.HLMoveClassToCommand);
  630. smalltalk.addMethod(
  631. smalltalk.method({
  632. selector: "key",
  633. protocol: 'accessing',
  634. fn: function (){
  635. var self=this;
  636. return "c";
  637. },
  638. args: [],
  639. source: "key\x0a\x09^ 'c'",
  640. messageSends: [],
  641. referencedClasses: []
  642. }),
  643. globals.HLMoveClassToCommand.klass);
  644. smalltalk.addMethod(
  645. smalltalk.method({
  646. selector: "label",
  647. protocol: 'accessing',
  648. fn: function (){
  649. var self=this;
  650. return "Class";
  651. },
  652. args: [],
  653. source: "label\x0a\x09^ 'Class'",
  654. messageSends: [],
  655. referencedClasses: []
  656. }),
  657. globals.HLMoveClassToCommand.klass);
  658. smalltalk.addClass('HLMoveClassToPackageCommand', globals.HLMoveClassToCommand, [], 'Helios-Commands-Tools');
  659. smalltalk.addMethod(
  660. smalltalk.method({
  661. selector: "category",
  662. protocol: 'accessing',
  663. fn: function (){
  664. var self=this;
  665. return "Classes";
  666. },
  667. args: [],
  668. source: "category\x0a\x09^ 'Classes'",
  669. messageSends: [],
  670. referencedClasses: []
  671. }),
  672. globals.HLMoveClassToPackageCommand);
  673. smalltalk.addMethod(
  674. smalltalk.method({
  675. selector: "displayLabel",
  676. protocol: 'accessing',
  677. fn: function (){
  678. var self=this;
  679. return "select a package";
  680. },
  681. args: [],
  682. source: "displayLabel\x0a\x09^ 'select a package'",
  683. messageSends: [],
  684. referencedClasses: []
  685. }),
  686. globals.HLMoveClassToPackageCommand);
  687. smalltalk.addMethod(
  688. smalltalk.method({
  689. selector: "execute",
  690. protocol: 'executing',
  691. fn: function (){
  692. var self=this;
  693. return smalltalk.withContext(function($ctx1) {
  694. _st(self._model())._moveClassToPackage_(self._input());
  695. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveClassToPackageCommand)})},
  696. args: [],
  697. source: "execute\x0a\x09self model moveClassToPackage: self input",
  698. messageSends: ["moveClassToPackage:", "model", "input"],
  699. referencedClasses: []
  700. }),
  701. globals.HLMoveClassToPackageCommand);
  702. smalltalk.addMethod(
  703. smalltalk.method({
  704. selector: "inputCompletion",
  705. protocol: 'accessing',
  706. fn: function (){
  707. var self=this;
  708. return smalltalk.withContext(function($ctx1) {
  709. var $1;
  710. $1=_st(self._model())._availablePackageNames();
  711. return $1;
  712. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveClassToPackageCommand)})},
  713. args: [],
  714. source: "inputCompletion\x0a\x09^ self model availablePackageNames",
  715. messageSends: ["availablePackageNames", "model"],
  716. referencedClasses: []
  717. }),
  718. globals.HLMoveClassToPackageCommand);
  719. smalltalk.addMethod(
  720. smalltalk.method({
  721. selector: "inputLabel",
  722. protocol: 'accessing',
  723. fn: function (){
  724. var self=this;
  725. return "Move class to package:";
  726. },
  727. args: [],
  728. source: "inputLabel\x0a\x09^ 'Move class to package:'",
  729. messageSends: [],
  730. referencedClasses: []
  731. }),
  732. globals.HLMoveClassToPackageCommand);
  733. smalltalk.addMethod(
  734. smalltalk.method({
  735. selector: "isInputRequired",
  736. protocol: 'testing',
  737. fn: function (){
  738. var self=this;
  739. return true;
  740. },
  741. args: [],
  742. source: "isInputRequired\x0a\x09^ true",
  743. messageSends: [],
  744. referencedClasses: []
  745. }),
  746. globals.HLMoveClassToPackageCommand);
  747. smalltalk.addMethod(
  748. smalltalk.method({
  749. selector: "key",
  750. protocol: 'accessing',
  751. fn: function (){
  752. var self=this;
  753. return "p";
  754. },
  755. args: [],
  756. source: "key\x0a\x09^ 'p'",
  757. messageSends: [],
  758. referencedClasses: []
  759. }),
  760. globals.HLMoveClassToPackageCommand.klass);
  761. smalltalk.addMethod(
  762. smalltalk.method({
  763. selector: "label",
  764. protocol: 'accessing',
  765. fn: function (){
  766. var self=this;
  767. return "to package";
  768. },
  769. args: [],
  770. source: "label\x0a\x09^ 'to package'",
  771. messageSends: [],
  772. referencedClasses: []
  773. }),
  774. globals.HLMoveClassToPackageCommand.klass);
  775. smalltalk.addMethod(
  776. smalltalk.method({
  777. selector: "menuLabel",
  778. protocol: 'accessing',
  779. fn: function (){
  780. var self=this;
  781. return "Move to package...";
  782. },
  783. args: [],
  784. source: "menuLabel\x09\x0a\x09^ 'Move to package...'",
  785. messageSends: [],
  786. referencedClasses: []
  787. }),
  788. globals.HLMoveClassToPackageCommand.klass);
  789. smalltalk.addClass('HLMoveMethodToCommand', globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
  790. smalltalk.addMethod(
  791. smalltalk.method({
  792. selector: "category",
  793. protocol: 'accessing',
  794. fn: function (){
  795. var self=this;
  796. return "Methods";
  797. },
  798. args: [],
  799. source: "category\x0a\x09^ 'Methods'",
  800. messageSends: [],
  801. referencedClasses: []
  802. }),
  803. globals.HLMoveMethodToCommand);
  804. smalltalk.addMethod(
  805. smalltalk.method({
  806. selector: "isActive",
  807. protocol: 'testing',
  808. fn: function (){
  809. var self=this;
  810. return smalltalk.withContext(function($ctx1) {
  811. var $1;
  812. $1=_st(_st(self._model())._selectedMethod())._notNil();
  813. return $1;
  814. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLMoveMethodToCommand)})},
  815. args: [],
  816. source: "isActive\x0a\x09^ self model selectedMethod notNil",
  817. messageSends: ["notNil", "selectedMethod", "model"],
  818. referencedClasses: []
  819. }),
  820. globals.HLMoveMethodToCommand);
  821. smalltalk.addMethod(
  822. smalltalk.method({
  823. selector: "key",
  824. protocol: 'accessing',
  825. fn: function (){
  826. var self=this;
  827. return "m";
  828. },
  829. args: [],
  830. source: "key\x0a\x09^ 'm'",
  831. messageSends: [],
  832. referencedClasses: []
  833. }),
  834. globals.HLMoveMethodToCommand.klass);
  835. smalltalk.addMethod(
  836. smalltalk.method({
  837. selector: "label",
  838. protocol: 'accessing',
  839. fn: function (){
  840. var self=this;
  841. return "Method";
  842. },
  843. args: [],
  844. source: "label\x0a\x09^ 'Method'",
  845. messageSends: [],
  846. referencedClasses: []
  847. }),
  848. globals.HLMoveMethodToCommand.klass);
  849. smalltalk.addClass('HLMoveMethodToClassCommand', globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
  850. smalltalk.addMethod(
  851. smalltalk.method({
  852. selector: "displayLabel",
  853. protocol: 'accessing',
  854. fn: function (){
  855. var self=this;
  856. return "select a class";
  857. },
  858. args: [],
  859. source: "displayLabel\x0a\x09^ 'select a class'",
  860. messageSends: [],
  861. referencedClasses: []
  862. }),
  863. globals.HLMoveMethodToClassCommand);
  864. smalltalk.addMethod(
  865. smalltalk.method({
  866. selector: "execute",
  867. protocol: 'executing',
  868. fn: function (){
  869. var self=this;
  870. return smalltalk.withContext(function($ctx1) {
  871. _st(self._model())._moveMethodToClass_(self._input());
  872. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveMethodToClassCommand)})},
  873. args: [],
  874. source: "execute\x0a\x09self model moveMethodToClass: self input",
  875. messageSends: ["moveMethodToClass:", "model", "input"],
  876. referencedClasses: []
  877. }),
  878. globals.HLMoveMethodToClassCommand);
  879. smalltalk.addMethod(
  880. smalltalk.method({
  881. selector: "inputCompletion",
  882. protocol: 'accessing',
  883. fn: function (){
  884. var self=this;
  885. return smalltalk.withContext(function($ctx1) {
  886. var $1;
  887. $1=_st(self._model())._availableClassNames();
  888. return $1;
  889. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveMethodToClassCommand)})},
  890. args: [],
  891. source: "inputCompletion\x0a\x09^ self model availableClassNames",
  892. messageSends: ["availableClassNames", "model"],
  893. referencedClasses: []
  894. }),
  895. globals.HLMoveMethodToClassCommand);
  896. smalltalk.addMethod(
  897. smalltalk.method({
  898. selector: "inputLabel",
  899. protocol: 'accessing',
  900. fn: function (){
  901. var self=this;
  902. return "Move method to class:";
  903. },
  904. args: [],
  905. source: "inputLabel\x0a\x09^ 'Move method to class:'",
  906. messageSends: [],
  907. referencedClasses: []
  908. }),
  909. globals.HLMoveMethodToClassCommand);
  910. smalltalk.addMethod(
  911. smalltalk.method({
  912. selector: "isInputRequired",
  913. protocol: 'testing',
  914. fn: function (){
  915. var self=this;
  916. return true;
  917. },
  918. args: [],
  919. source: "isInputRequired\x0a\x09^ true",
  920. messageSends: [],
  921. referencedClasses: []
  922. }),
  923. globals.HLMoveMethodToClassCommand);
  924. smalltalk.addMethod(
  925. smalltalk.method({
  926. selector: "key",
  927. protocol: 'accessing',
  928. fn: function (){
  929. var self=this;
  930. return "c";
  931. },
  932. args: [],
  933. source: "key\x0a\x09^ 'c'",
  934. messageSends: [],
  935. referencedClasses: []
  936. }),
  937. globals.HLMoveMethodToClassCommand.klass);
  938. smalltalk.addMethod(
  939. smalltalk.method({
  940. selector: "label",
  941. protocol: 'accessing',
  942. fn: function (){
  943. var self=this;
  944. return "to class";
  945. },
  946. args: [],
  947. source: "label\x09\x0a\x09^ 'to class'",
  948. messageSends: [],
  949. referencedClasses: []
  950. }),
  951. globals.HLMoveMethodToClassCommand.klass);
  952. smalltalk.addMethod(
  953. smalltalk.method({
  954. selector: "menuLabel",
  955. protocol: 'accessing',
  956. fn: function (){
  957. var self=this;
  958. return "Move to class...";
  959. },
  960. args: [],
  961. source: "menuLabel\x09\x0a\x09^ 'Move to class...'",
  962. messageSends: [],
  963. referencedClasses: []
  964. }),
  965. globals.HLMoveMethodToClassCommand.klass);
  966. smalltalk.addClass('HLMoveMethodToProtocolCommand', globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
  967. smalltalk.addMethod(
  968. smalltalk.method({
  969. selector: "displayLabel",
  970. protocol: 'accessing',
  971. fn: function (){
  972. var self=this;
  973. return "select a protocol";
  974. },
  975. args: [],
  976. source: "displayLabel\x0a\x09^ 'select a protocol'",
  977. messageSends: [],
  978. referencedClasses: []
  979. }),
  980. globals.HLMoveMethodToProtocolCommand);
  981. smalltalk.addMethod(
  982. smalltalk.method({
  983. selector: "execute",
  984. protocol: 'executing',
  985. fn: function (){
  986. var self=this;
  987. return smalltalk.withContext(function($ctx1) {
  988. _st(self._model())._moveMethodToProtocol_(self._input());
  989. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveMethodToProtocolCommand)})},
  990. args: [],
  991. source: "execute\x0a\x09self model moveMethodToProtocol: self input",
  992. messageSends: ["moveMethodToProtocol:", "model", "input"],
  993. referencedClasses: []
  994. }),
  995. globals.HLMoveMethodToProtocolCommand);
  996. smalltalk.addMethod(
  997. smalltalk.method({
  998. selector: "inputCompletion",
  999. protocol: 'accessing',
  1000. fn: function (){
  1001. var self=this;
  1002. return smalltalk.withContext(function($ctx1) {
  1003. var $1;
  1004. $1=_st(self._model())._availableProtocols();
  1005. return $1;
  1006. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveMethodToProtocolCommand)})},
  1007. args: [],
  1008. source: "inputCompletion\x0a\x09^ self model availableProtocols",
  1009. messageSends: ["availableProtocols", "model"],
  1010. referencedClasses: []
  1011. }),
  1012. globals.HLMoveMethodToProtocolCommand);
  1013. smalltalk.addMethod(
  1014. smalltalk.method({
  1015. selector: "inputLabel",
  1016. protocol: 'accessing',
  1017. fn: function (){
  1018. var self=this;
  1019. return "Move method to a protocol:";
  1020. },
  1021. args: [],
  1022. source: "inputLabel\x0a\x09^ 'Move method to a protocol:'",
  1023. messageSends: [],
  1024. referencedClasses: []
  1025. }),
  1026. globals.HLMoveMethodToProtocolCommand);
  1027. smalltalk.addMethod(
  1028. smalltalk.method({
  1029. selector: "isInputRequired",
  1030. protocol: 'testing',
  1031. fn: function (){
  1032. var self=this;
  1033. return true;
  1034. },
  1035. args: [],
  1036. source: "isInputRequired\x0a\x09^ true",
  1037. messageSends: [],
  1038. referencedClasses: []
  1039. }),
  1040. globals.HLMoveMethodToProtocolCommand);
  1041. smalltalk.addMethod(
  1042. smalltalk.method({
  1043. selector: "key",
  1044. protocol: 'accessing',
  1045. fn: function (){
  1046. var self=this;
  1047. return "t";
  1048. },
  1049. args: [],
  1050. source: "key\x0a\x09^ 't'",
  1051. messageSends: [],
  1052. referencedClasses: []
  1053. }),
  1054. globals.HLMoveMethodToProtocolCommand.klass);
  1055. smalltalk.addMethod(
  1056. smalltalk.method({
  1057. selector: "label",
  1058. protocol: 'accessing',
  1059. fn: function (){
  1060. var self=this;
  1061. return "to protocol";
  1062. },
  1063. args: [],
  1064. source: "label\x0a\x09^ 'to protocol'",
  1065. messageSends: [],
  1066. referencedClasses: []
  1067. }),
  1068. globals.HLMoveMethodToProtocolCommand.klass);
  1069. smalltalk.addMethod(
  1070. smalltalk.method({
  1071. selector: "menuLabel",
  1072. protocol: 'accessing',
  1073. fn: function (){
  1074. var self=this;
  1075. return "Move to protocol...";
  1076. },
  1077. args: [],
  1078. source: "menuLabel\x0a\x09^ 'Move to protocol...'",
  1079. messageSends: [],
  1080. referencedClasses: []
  1081. }),
  1082. globals.HLMoveMethodToProtocolCommand.klass);
  1083. smalltalk.addClass('HLRemoveCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
  1084. smalltalk.addMethod(
  1085. smalltalk.method({
  1086. selector: "key",
  1087. protocol: 'accessing',
  1088. fn: function (){
  1089. var self=this;
  1090. return "x";
  1091. },
  1092. args: [],
  1093. source: "key\x0a\x09^ 'x'",
  1094. messageSends: [],
  1095. referencedClasses: []
  1096. }),
  1097. globals.HLRemoveCommand.klass);
  1098. smalltalk.addMethod(
  1099. smalltalk.method({
  1100. selector: "label",
  1101. protocol: 'accessing',
  1102. fn: function (){
  1103. var self=this;
  1104. return "Remove";
  1105. },
  1106. args: [],
  1107. source: "label\x0a\x09^ 'Remove'",
  1108. messageSends: [],
  1109. referencedClasses: []
  1110. }),
  1111. globals.HLRemoveCommand.klass);
  1112. smalltalk.addClass('HLRemoveClassCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
  1113. smalltalk.addMethod(
  1114. smalltalk.method({
  1115. selector: "category",
  1116. protocol: 'accessing',
  1117. fn: function (){
  1118. var self=this;
  1119. return "Classes";
  1120. },
  1121. args: [],
  1122. source: "category\x0a\x09^ 'Classes'",
  1123. messageSends: [],
  1124. referencedClasses: []
  1125. }),
  1126. globals.HLRemoveClassCommand);
  1127. smalltalk.addMethod(
  1128. smalltalk.method({
  1129. selector: "execute",
  1130. protocol: 'executing',
  1131. fn: function (){
  1132. var self=this;
  1133. return smalltalk.withContext(function($ctx1) {
  1134. _st(self._model())._removeClass();
  1135. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveClassCommand)})},
  1136. args: [],
  1137. source: "execute\x0a\x09self model removeClass",
  1138. messageSends: ["removeClass", "model"],
  1139. referencedClasses: []
  1140. }),
  1141. globals.HLRemoveClassCommand);
  1142. smalltalk.addMethod(
  1143. smalltalk.method({
  1144. selector: "isActive",
  1145. protocol: 'testing',
  1146. fn: function (){
  1147. var self=this;
  1148. return smalltalk.withContext(function($ctx1) {
  1149. var $1;
  1150. $1=_st(_st(self._model())._selectedClass())._notNil();
  1151. return $1;
  1152. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveClassCommand)})},
  1153. args: [],
  1154. source: "isActive\x0a\x09^ self model selectedClass notNil",
  1155. messageSends: ["notNil", "selectedClass", "model"],
  1156. referencedClasses: []
  1157. }),
  1158. globals.HLRemoveClassCommand);
  1159. smalltalk.addMethod(
  1160. smalltalk.method({
  1161. selector: "key",
  1162. protocol: 'accessing',
  1163. fn: function (){
  1164. var self=this;
  1165. return "c";
  1166. },
  1167. args: [],
  1168. source: "key\x0a\x09^ 'c'",
  1169. messageSends: [],
  1170. referencedClasses: []
  1171. }),
  1172. globals.HLRemoveClassCommand.klass);
  1173. smalltalk.addMethod(
  1174. smalltalk.method({
  1175. selector: "label",
  1176. protocol: 'accessing',
  1177. fn: function (){
  1178. var self=this;
  1179. return "Class";
  1180. },
  1181. args: [],
  1182. source: "label\x0a\x09^ 'Class'",
  1183. messageSends: [],
  1184. referencedClasses: []
  1185. }),
  1186. globals.HLRemoveClassCommand.klass);
  1187. smalltalk.addMethod(
  1188. smalltalk.method({
  1189. selector: "menuLabel",
  1190. protocol: 'accessing',
  1191. fn: function (){
  1192. var self=this;
  1193. return "Remove class";
  1194. },
  1195. args: [],
  1196. source: "menuLabel\x0a\x09^ 'Remove class'",
  1197. messageSends: [],
  1198. referencedClasses: []
  1199. }),
  1200. globals.HLRemoveClassCommand.klass);
  1201. smalltalk.addClass('HLRemoveMethodCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
  1202. smalltalk.addMethod(
  1203. smalltalk.method({
  1204. selector: "category",
  1205. protocol: 'accessing',
  1206. fn: function (){
  1207. var self=this;
  1208. return "Methods";
  1209. },
  1210. args: [],
  1211. source: "category\x0a\x09^ 'Methods'",
  1212. messageSends: [],
  1213. referencedClasses: []
  1214. }),
  1215. globals.HLRemoveMethodCommand);
  1216. smalltalk.addMethod(
  1217. smalltalk.method({
  1218. selector: "execute",
  1219. protocol: 'executing',
  1220. fn: function (){
  1221. var self=this;
  1222. return smalltalk.withContext(function($ctx1) {
  1223. _st(self._model())._removeMethod();
  1224. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveMethodCommand)})},
  1225. args: [],
  1226. source: "execute\x0a\x09self model removeMethod",
  1227. messageSends: ["removeMethod", "model"],
  1228. referencedClasses: []
  1229. }),
  1230. globals.HLRemoveMethodCommand);
  1231. smalltalk.addMethod(
  1232. smalltalk.method({
  1233. selector: "isActive",
  1234. protocol: 'testing',
  1235. fn: function (){
  1236. var self=this;
  1237. return smalltalk.withContext(function($ctx1) {
  1238. var $1;
  1239. $1=_st(_st(self._model())._selectedMethod())._notNil();
  1240. return $1;
  1241. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveMethodCommand)})},
  1242. args: [],
  1243. source: "isActive\x0a\x09^ self model selectedMethod notNil",
  1244. messageSends: ["notNil", "selectedMethod", "model"],
  1245. referencedClasses: []
  1246. }),
  1247. globals.HLRemoveMethodCommand);
  1248. smalltalk.addMethod(
  1249. smalltalk.method({
  1250. selector: "key",
  1251. protocol: 'accessing',
  1252. fn: function (){
  1253. var self=this;
  1254. return "m";
  1255. },
  1256. args: [],
  1257. source: "key\x0a\x09^ 'm'",
  1258. messageSends: [],
  1259. referencedClasses: []
  1260. }),
  1261. globals.HLRemoveMethodCommand.klass);
  1262. smalltalk.addMethod(
  1263. smalltalk.method({
  1264. selector: "label",
  1265. protocol: 'accessing',
  1266. fn: function (){
  1267. var self=this;
  1268. return "Method";
  1269. },
  1270. args: [],
  1271. source: "label\x0a\x09^ 'Method'",
  1272. messageSends: [],
  1273. referencedClasses: []
  1274. }),
  1275. globals.HLRemoveMethodCommand.klass);
  1276. smalltalk.addMethod(
  1277. smalltalk.method({
  1278. selector: "menuLabel",
  1279. protocol: 'accessing',
  1280. fn: function (){
  1281. var self=this;
  1282. return "Remove method";
  1283. },
  1284. args: [],
  1285. source: "menuLabel\x0a\x09^ 'Remove method'",
  1286. messageSends: [],
  1287. referencedClasses: []
  1288. }),
  1289. globals.HLRemoveMethodCommand.klass);
  1290. smalltalk.addClass('HLRemoveProtocolCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
  1291. smalltalk.addMethod(
  1292. smalltalk.method({
  1293. selector: "category",
  1294. protocol: 'accessing',
  1295. fn: function (){
  1296. var self=this;
  1297. return "Protocols";
  1298. },
  1299. args: [],
  1300. source: "category\x0a\x09^ 'Protocols'",
  1301. messageSends: [],
  1302. referencedClasses: []
  1303. }),
  1304. globals.HLRemoveProtocolCommand);
  1305. smalltalk.addMethod(
  1306. smalltalk.method({
  1307. selector: "execute",
  1308. protocol: 'executing',
  1309. fn: function (){
  1310. var self=this;
  1311. return smalltalk.withContext(function($ctx1) {
  1312. _st(self._model())._removeProtocol();
  1313. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveProtocolCommand)})},
  1314. args: [],
  1315. source: "execute\x0a\x09self model removeProtocol",
  1316. messageSends: ["removeProtocol", "model"],
  1317. referencedClasses: []
  1318. }),
  1319. globals.HLRemoveProtocolCommand);
  1320. smalltalk.addMethod(
  1321. smalltalk.method({
  1322. selector: "isActive",
  1323. protocol: 'testing',
  1324. fn: function (){
  1325. var self=this;
  1326. return smalltalk.withContext(function($ctx1) {
  1327. var $1;
  1328. $1=_st(_st(self._model())._selectedProtocol())._notNil();
  1329. return $1;
  1330. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveProtocolCommand)})},
  1331. args: [],
  1332. source: "isActive\x0a\x09^ self model selectedProtocol notNil",
  1333. messageSends: ["notNil", "selectedProtocol", "model"],
  1334. referencedClasses: []
  1335. }),
  1336. globals.HLRemoveProtocolCommand);
  1337. smalltalk.addMethod(
  1338. smalltalk.method({
  1339. selector: "key",
  1340. protocol: 'accessing',
  1341. fn: function (){
  1342. var self=this;
  1343. return "t";
  1344. },
  1345. args: [],
  1346. source: "key\x0a\x09^ 't'",
  1347. messageSends: [],
  1348. referencedClasses: []
  1349. }),
  1350. globals.HLRemoveProtocolCommand.klass);
  1351. smalltalk.addMethod(
  1352. smalltalk.method({
  1353. selector: "label",
  1354. protocol: 'accessing',
  1355. fn: function (){
  1356. var self=this;
  1357. return "Protocol";
  1358. },
  1359. args: [],
  1360. source: "label\x0a\x09^ 'Protocol'",
  1361. messageSends: [],
  1362. referencedClasses: []
  1363. }),
  1364. globals.HLRemoveProtocolCommand.klass);
  1365. smalltalk.addMethod(
  1366. smalltalk.method({
  1367. selector: "menuLabel",
  1368. protocol: 'accessing',
  1369. fn: function (){
  1370. var self=this;
  1371. return "Remove protocol";
  1372. },
  1373. args: [],
  1374. source: "menuLabel\x0a\x09^ 'Remove protocol'",
  1375. messageSends: [],
  1376. referencedClasses: []
  1377. }),
  1378. globals.HLRemoveProtocolCommand.klass);
  1379. smalltalk.addClass('HLRenameCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
  1380. smalltalk.addMethod(
  1381. smalltalk.method({
  1382. selector: "key",
  1383. protocol: 'accessing',
  1384. fn: function (){
  1385. var self=this;
  1386. return "r";
  1387. },
  1388. args: [],
  1389. source: "key\x0a\x09^ 'r'",
  1390. messageSends: [],
  1391. referencedClasses: []
  1392. }),
  1393. globals.HLRenameCommand.klass);
  1394. smalltalk.addMethod(
  1395. smalltalk.method({
  1396. selector: "label",
  1397. protocol: 'accessing',
  1398. fn: function (){
  1399. var self=this;
  1400. return "Rename";
  1401. },
  1402. args: [],
  1403. source: "label\x0a\x09^ 'Rename'",
  1404. messageSends: [],
  1405. referencedClasses: []
  1406. }),
  1407. globals.HLRenameCommand.klass);
  1408. smalltalk.addClass('HLRenameClassCommand', globals.HLRenameCommand, [], 'Helios-Commands-Tools');
  1409. smalltalk.addMethod(
  1410. smalltalk.method({
  1411. selector: "category",
  1412. protocol: 'accessing',
  1413. fn: function (){
  1414. var self=this;
  1415. return "Classes";
  1416. },
  1417. args: [],
  1418. source: "category\x0a\x09^ 'Classes'",
  1419. messageSends: [],
  1420. referencedClasses: []
  1421. }),
  1422. globals.HLRenameClassCommand);
  1423. smalltalk.addMethod(
  1424. smalltalk.method({
  1425. selector: "defaultInput",
  1426. protocol: 'defaults',
  1427. fn: function (){
  1428. var self=this;
  1429. return smalltalk.withContext(function($ctx1) {
  1430. var $1;
  1431. $1=_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name();
  1432. return $1;
  1433. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLRenameClassCommand)})},
  1434. args: [],
  1435. source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
  1436. messageSends: ["name", "theNonMetaClass", "selectedClass", "model"],
  1437. referencedClasses: []
  1438. }),
  1439. globals.HLRenameClassCommand);
  1440. smalltalk.addMethod(
  1441. smalltalk.method({
  1442. selector: "displayLabel",
  1443. protocol: 'accessing',
  1444. fn: function (){
  1445. var self=this;
  1446. return "Rename class to:";
  1447. },
  1448. args: [],
  1449. source: "displayLabel\x0a\x09^ 'Rename class to:'",
  1450. messageSends: [],
  1451. referencedClasses: []
  1452. }),
  1453. globals.HLRenameClassCommand);
  1454. smalltalk.addMethod(
  1455. smalltalk.method({
  1456. selector: "execute",
  1457. protocol: 'executing',
  1458. fn: function (){
  1459. var self=this;
  1460. return smalltalk.withContext(function($ctx1) {
  1461. _st(self._model())._renameClassTo_(self._input());
  1462. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRenameClassCommand)})},
  1463. args: [],
  1464. source: "execute\x0a\x09self model renameClassTo: self input",
  1465. messageSends: ["renameClassTo:", "model", "input"],
  1466. referencedClasses: []
  1467. }),
  1468. globals.HLRenameClassCommand);
  1469. smalltalk.addMethod(
  1470. smalltalk.method({
  1471. selector: "isActive",
  1472. protocol: 'testing',
  1473. fn: function (){
  1474. var self=this;
  1475. return smalltalk.withContext(function($ctx1) {
  1476. var $1;
  1477. $1=_st(_st(self._model())._selectedClass())._notNil();
  1478. return $1;
  1479. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRenameClassCommand)})},
  1480. args: [],
  1481. source: "isActive\x0a\x09^ self model selectedClass notNil",
  1482. messageSends: ["notNil", "selectedClass", "model"],
  1483. referencedClasses: []
  1484. }),
  1485. globals.HLRenameClassCommand);
  1486. smalltalk.addMethod(
  1487. smalltalk.method({
  1488. selector: "isInputRequired",
  1489. protocol: 'testing',
  1490. fn: function (){
  1491. var self=this;
  1492. return true;
  1493. },
  1494. args: [],
  1495. source: "isInputRequired\x0a\x09^ true",
  1496. messageSends: [],
  1497. referencedClasses: []
  1498. }),
  1499. globals.HLRenameClassCommand);
  1500. smalltalk.addMethod(
  1501. smalltalk.method({
  1502. selector: "key",
  1503. protocol: 'accessing',
  1504. fn: function (){
  1505. var self=this;
  1506. return "c";
  1507. },
  1508. args: [],
  1509. source: "key\x0a\x09^ 'c'",
  1510. messageSends: [],
  1511. referencedClasses: []
  1512. }),
  1513. globals.HLRenameClassCommand.klass);
  1514. smalltalk.addMethod(
  1515. smalltalk.method({
  1516. selector: "label",
  1517. protocol: 'accessing',
  1518. fn: function (){
  1519. var self=this;
  1520. return "Class";
  1521. },
  1522. args: [],
  1523. source: "label\x0a\x09^ 'Class'",
  1524. messageSends: [],
  1525. referencedClasses: []
  1526. }),
  1527. globals.HLRenameClassCommand.klass);
  1528. smalltalk.addMethod(
  1529. smalltalk.method({
  1530. selector: "menuLabel",
  1531. protocol: 'accessing',
  1532. fn: function (){
  1533. var self=this;
  1534. return "Rename class...";
  1535. },
  1536. args: [],
  1537. source: "menuLabel\x0a\x09^ 'Rename class...'",
  1538. messageSends: [],
  1539. referencedClasses: []
  1540. }),
  1541. globals.HLRenameClassCommand.klass);
  1542. smalltalk.addClass('HLRenameProtocolCommand', globals.HLRenameCommand, [], 'Helios-Commands-Tools');
  1543. smalltalk.addMethod(
  1544. smalltalk.method({
  1545. selector: "category",
  1546. protocol: 'accessing',
  1547. fn: function (){
  1548. var self=this;
  1549. return "Protocols";
  1550. },
  1551. args: [],
  1552. source: "category\x0a\x09^ 'Protocols'",
  1553. messageSends: [],
  1554. referencedClasses: []
  1555. }),
  1556. globals.HLRenameProtocolCommand);
  1557. smalltalk.addMethod(
  1558. smalltalk.method({
  1559. selector: "defaultInput",
  1560. protocol: 'defaults',
  1561. fn: function (){
  1562. var self=this;
  1563. return smalltalk.withContext(function($ctx1) {
  1564. var $1;
  1565. $1=_st(self._model())._selectedProtocol();
  1566. return $1;
  1567. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLRenameProtocolCommand)})},
  1568. args: [],
  1569. source: "defaultInput\x0a\x09^ self model selectedProtocol",
  1570. messageSends: ["selectedProtocol", "model"],
  1571. referencedClasses: []
  1572. }),
  1573. globals.HLRenameProtocolCommand);
  1574. smalltalk.addMethod(
  1575. smalltalk.method({
  1576. selector: "displayLabel",
  1577. protocol: 'accessing',
  1578. fn: function (){
  1579. var self=this;
  1580. return "Rename protocol to:";
  1581. },
  1582. args: [],
  1583. source: "displayLabel\x0a\x09^ 'Rename protocol to:'",
  1584. messageSends: [],
  1585. referencedClasses: []
  1586. }),
  1587. globals.HLRenameProtocolCommand);
  1588. smalltalk.addMethod(
  1589. smalltalk.method({
  1590. selector: "execute",
  1591. protocol: 'executing',
  1592. fn: function (){
  1593. var self=this;
  1594. return smalltalk.withContext(function($ctx1) {
  1595. _st(self._model())._renameProtocolTo_(self._input());
  1596. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRenameProtocolCommand)})},
  1597. args: [],
  1598. source: "execute\x0a\x09self model renameProtocolTo: self input",
  1599. messageSends: ["renameProtocolTo:", "model", "input"],
  1600. referencedClasses: []
  1601. }),
  1602. globals.HLRenameProtocolCommand);
  1603. smalltalk.addMethod(
  1604. smalltalk.method({
  1605. selector: "isActive",
  1606. protocol: 'testing',
  1607. fn: function (){
  1608. var self=this;
  1609. return smalltalk.withContext(function($ctx1) {
  1610. var $1;
  1611. $1=_st(_st(self._model())._selectedProtocol())._notNil();
  1612. return $1;
  1613. }, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRenameProtocolCommand)})},
  1614. args: [],
  1615. source: "isActive\x0a\x09^ self model selectedProtocol notNil",
  1616. messageSends: ["notNil", "selectedProtocol", "model"],
  1617. referencedClasses: []
  1618. }),
  1619. globals.HLRenameProtocolCommand);
  1620. smalltalk.addMethod(
  1621. smalltalk.method({
  1622. selector: "isInputRequired",
  1623. protocol: 'testing',
  1624. fn: function (){
  1625. var self=this;
  1626. return true;
  1627. },
  1628. args: [],
  1629. source: "isInputRequired\x0a\x09^ true",
  1630. messageSends: [],
  1631. referencedClasses: []
  1632. }),
  1633. globals.HLRenameProtocolCommand);
  1634. smalltalk.addMethod(
  1635. smalltalk.method({
  1636. selector: "key",
  1637. protocol: 'accessing',
  1638. fn: function (){
  1639. var self=this;
  1640. return "t";
  1641. },
  1642. args: [],
  1643. source: "key\x0a\x09^ 't'",
  1644. messageSends: [],
  1645. referencedClasses: []
  1646. }),
  1647. globals.HLRenameProtocolCommand.klass);
  1648. smalltalk.addMethod(
  1649. smalltalk.method({
  1650. selector: "label",
  1651. protocol: 'accessing',
  1652. fn: function (){
  1653. var self=this;
  1654. return "Protocol";
  1655. },
  1656. args: [],
  1657. source: "label\x0a\x09^ 'Protocol'",
  1658. messageSends: [],
  1659. referencedClasses: []
  1660. }),
  1661. globals.HLRenameProtocolCommand.klass);
  1662. smalltalk.addMethod(
  1663. smalltalk.method({
  1664. selector: "menuLabel",
  1665. protocol: 'accessing',
  1666. fn: function (){
  1667. var self=this;
  1668. return "Rename protocol...";
  1669. },
  1670. args: [],
  1671. source: "menuLabel\x0a\x09^ 'Rename protocol...'",
  1672. messageSends: [],
  1673. referencedClasses: []
  1674. }),
  1675. globals.HLRenameProtocolCommand.klass);
  1676. });