2
0

Helios-Commands-Tools.js 42 KB

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