Helios-Commands-Tools.js 44 KB

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