1
0

Helios-Commands-Tools.js 61 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621
  1. define("helios/Helios-Commands-Tools", ["amber/boot", "helios/Helios-Commands-Core"], function($boot){"use strict";
  2. var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
  3. $core.addPackage('Helios-Commands-Tools');
  4. $core.packages["Helios-Commands-Tools"].innerEval = function (expr) { return eval(expr); };
  5. $core.packages["Helios-Commands-Tools"].transport = {"type":"amd","amdNamespace":"helios"};
  6. $core.addClass('HLToolCommand', $globals.HLModelCommand, [], 'Helios-Commands-Tools');
  7. $core.addMethod(
  8. $core.method({
  9. selector: "category",
  10. protocol: 'accessing',
  11. fn: function (){
  12. var self=this;
  13. return nil;
  14. },
  15. //>>excludeStart("ide", pragmas.excludeIdeData);
  16. args: [],
  17. source: "category\x0a\x09^ nil",
  18. referencedClasses: [],
  19. //>>excludeEnd("ide");
  20. messageSends: []
  21. }),
  22. $globals.HLToolCommand);
  23. $core.addMethod(
  24. $core.method({
  25. selector: "for:",
  26. protocol: 'instance creation',
  27. fn: function (aToolModel){
  28. var self=this;
  29. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  30. return $core.withContext(function($ctx1) {
  31. //>>excludeEnd("ctx");
  32. var $1;
  33. $1=self._new();
  34. $recv($1)._model_(aToolModel);
  35. return $recv($1)._yourself();
  36. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  37. }, function($ctx1) {$ctx1.fill(self,"for:",{aToolModel:aToolModel},$globals.HLToolCommand.klass)});
  38. //>>excludeEnd("ctx");
  39. },
  40. //>>excludeStart("ide", pragmas.excludeIdeData);
  41. args: ["aToolModel"],
  42. source: "for: aToolModel\x0a\x09^ self new\x0a \x09model: aToolModel;\x0a yourself",
  43. referencedClasses: [],
  44. //>>excludeEnd("ide");
  45. messageSends: ["model:", "new", "yourself"]
  46. }),
  47. $globals.HLToolCommand.klass);
  48. $core.addMethod(
  49. $core.method({
  50. selector: "isValidFor:",
  51. protocol: 'testing',
  52. fn: function (aModel){
  53. var self=this;
  54. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  55. return $core.withContext(function($ctx1) {
  56. //>>excludeEnd("ctx");
  57. return $recv(aModel)._isToolModel();
  58. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  59. }, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLToolCommand.klass)});
  60. //>>excludeEnd("ctx");
  61. },
  62. //>>excludeStart("ide", pragmas.excludeIdeData);
  63. args: ["aModel"],
  64. source: "isValidFor: aModel\x0a\x09^ aModel isToolModel",
  65. referencedClasses: [],
  66. //>>excludeEnd("ide");
  67. messageSends: ["isToolModel"]
  68. }),
  69. $globals.HLToolCommand.klass);
  70. $core.addClass('HLBrowseMethodCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  71. $core.addMethod(
  72. $core.method({
  73. selector: "displayLabel",
  74. protocol: 'accessing',
  75. fn: function (){
  76. var self=this;
  77. return "browse method";
  78. },
  79. //>>excludeStart("ide", pragmas.excludeIdeData);
  80. args: [],
  81. source: "displayLabel\x0a\x09^ 'browse method'",
  82. referencedClasses: [],
  83. //>>excludeEnd("ide");
  84. messageSends: []
  85. }),
  86. $globals.HLBrowseMethodCommand);
  87. $core.addMethod(
  88. $core.method({
  89. selector: "execute",
  90. protocol: 'executing',
  91. fn: function (){
  92. var self=this;
  93. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  94. return $core.withContext(function($ctx1) {
  95. //>>excludeEnd("ctx");
  96. $recv(self._model())._openMethod();
  97. return self;
  98. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  99. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLBrowseMethodCommand)});
  100. //>>excludeEnd("ctx");
  101. },
  102. //>>excludeStart("ide", pragmas.excludeIdeData);
  103. args: [],
  104. source: "execute\x0a\x09self model openMethod",
  105. referencedClasses: [],
  106. //>>excludeEnd("ide");
  107. messageSends: ["openMethod", "model"]
  108. }),
  109. $globals.HLBrowseMethodCommand);
  110. $core.addMethod(
  111. $core.method({
  112. selector: "isValidFor:",
  113. protocol: 'testing',
  114. fn: function (aModel){
  115. var self=this;
  116. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  117. return $core.withContext(function($ctx1) {
  118. //>>excludeEnd("ctx");
  119. return $recv(aModel)._isReferencesModel();
  120. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  121. }, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLBrowseMethodCommand.klass)});
  122. //>>excludeEnd("ctx");
  123. },
  124. //>>excludeStart("ide", pragmas.excludeIdeData);
  125. args: ["aModel"],
  126. source: "isValidFor: aModel\x0a\x09^ aModel isReferencesModel",
  127. referencedClasses: [],
  128. //>>excludeEnd("ide");
  129. messageSends: ["isReferencesModel"]
  130. }),
  131. $globals.HLBrowseMethodCommand.klass);
  132. $core.addMethod(
  133. $core.method({
  134. selector: "key",
  135. protocol: 'accessing',
  136. fn: function (){
  137. var self=this;
  138. return "b";
  139. },
  140. //>>excludeStart("ide", pragmas.excludeIdeData);
  141. args: [],
  142. source: "key\x0a\x09^ 'b'",
  143. referencedClasses: [],
  144. //>>excludeEnd("ide");
  145. messageSends: []
  146. }),
  147. $globals.HLBrowseMethodCommand.klass);
  148. $core.addMethod(
  149. $core.method({
  150. selector: "label",
  151. protocol: 'accessing',
  152. fn: function (){
  153. var self=this;
  154. return "browse method";
  155. },
  156. //>>excludeStart("ide", pragmas.excludeIdeData);
  157. args: [],
  158. source: "label\x0a\x09^ 'browse method'",
  159. referencedClasses: [],
  160. //>>excludeEnd("ide");
  161. messageSends: []
  162. }),
  163. $globals.HLBrowseMethodCommand.klass);
  164. $core.addClass('HLCommitPackageCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  165. $core.addMethod(
  166. $core.method({
  167. selector: "category",
  168. protocol: 'accessing',
  169. fn: function (){
  170. var self=this;
  171. return "Packages";
  172. },
  173. //>>excludeStart("ide", pragmas.excludeIdeData);
  174. args: [],
  175. source: "category\x0a\x09^ 'Packages'",
  176. referencedClasses: [],
  177. //>>excludeEnd("ide");
  178. messageSends: []
  179. }),
  180. $globals.HLCommitPackageCommand);
  181. $core.addMethod(
  182. $core.method({
  183. selector: "commitPackage",
  184. protocol: 'executing',
  185. fn: function (){
  186. var self=this;
  187. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  188. return $core.withContext(function($ctx1) {
  189. //>>excludeEnd("ctx");
  190. $recv(self._model())._commitPackageOnSuccess_onError_((function(){
  191. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  192. return $core.withContext(function($ctx2) {
  193. //>>excludeEnd("ctx");
  194. return self._informSuccess();
  195. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  196. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
  197. //>>excludeEnd("ctx");
  198. }),(function(error){
  199. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  200. return $core.withContext(function($ctx2) {
  201. //>>excludeEnd("ctx");
  202. return self._onPackageCommitError_(error);
  203. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  204. }, function($ctx2) {$ctx2.fillBlock({error:error},$ctx1,2)});
  205. //>>excludeEnd("ctx");
  206. }));
  207. return self;
  208. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  209. }, function($ctx1) {$ctx1.fill(self,"commitPackage",{},$globals.HLCommitPackageCommand)});
  210. //>>excludeEnd("ctx");
  211. },
  212. //>>excludeStart("ide", pragmas.excludeIdeData);
  213. args: [],
  214. source: "commitPackage\x0a\x09self model \x0a\x09\x09commitPackageOnSuccess: [ self informSuccess ]\x0a\x09\x09onError: [ :error | self onPackageCommitError: error ]",
  215. referencedClasses: [],
  216. //>>excludeEnd("ide");
  217. messageSends: ["commitPackageOnSuccess:onError:", "model", "informSuccess", "onPackageCommitError:"]
  218. }),
  219. $globals.HLCommitPackageCommand);
  220. $core.addMethod(
  221. $core.method({
  222. selector: "execute",
  223. protocol: 'executing',
  224. fn: function (){
  225. var self=this;
  226. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  227. return $core.withContext(function($ctx1) {
  228. //>>excludeEnd("ctx");
  229. self._commitPackage();
  230. return self;
  231. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  232. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLCommitPackageCommand)});
  233. //>>excludeEnd("ctx");
  234. },
  235. //>>excludeStart("ide", pragmas.excludeIdeData);
  236. args: [],
  237. source: "execute\x0a\x09self commitPackage",
  238. referencedClasses: [],
  239. //>>excludeEnd("ide");
  240. messageSends: ["commitPackage"]
  241. }),
  242. $globals.HLCommitPackageCommand);
  243. $core.addMethod(
  244. $core.method({
  245. selector: "informSuccess",
  246. protocol: 'executing',
  247. fn: function (){
  248. var self=this;
  249. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  250. return $core.withContext(function($ctx1) {
  251. //>>excludeEnd("ctx");
  252. var $1;
  253. $1=$recv($globals.HLInformationWidget)._new();
  254. $recv($1)._informationString_("Commit successful!");
  255. $recv($1)._show();
  256. return self;
  257. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  258. }, function($ctx1) {$ctx1.fill(self,"informSuccess",{},$globals.HLCommitPackageCommand)});
  259. //>>excludeEnd("ctx");
  260. },
  261. //>>excludeStart("ide", pragmas.excludeIdeData);
  262. args: [],
  263. source: "informSuccess\x0a\x09HLInformationWidget new\x0a\x09\x09informationString: 'Commit successful!';\x0a\x09\x09show",
  264. referencedClasses: ["HLInformationWidget"],
  265. //>>excludeEnd("ide");
  266. messageSends: ["informationString:", "new", "show"]
  267. }),
  268. $globals.HLCommitPackageCommand);
  269. $core.addMethod(
  270. $core.method({
  271. selector: "isActive",
  272. protocol: 'testing',
  273. fn: function (){
  274. var self=this;
  275. return true;
  276. },
  277. //>>excludeStart("ide", pragmas.excludeIdeData);
  278. args: [],
  279. source: "isActive\x0a\x09^ true\x0a\x09\x22self model isPackageDirty\x22",
  280. referencedClasses: [],
  281. //>>excludeEnd("ide");
  282. messageSends: []
  283. }),
  284. $globals.HLCommitPackageCommand);
  285. $core.addMethod(
  286. $core.method({
  287. selector: "onPackageCommitError:",
  288. protocol: 'error handling',
  289. fn: function (anError){
  290. var self=this;
  291. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  292. return $core.withContext(function($ctx1) {
  293. //>>excludeEnd("ctx");
  294. $recv($recv($globals.HLPackageCommitErrorHelper)._on_(self._model()))._showHelp();
  295. return self;
  296. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  297. }, function($ctx1) {$ctx1.fill(self,"onPackageCommitError:",{anError:anError},$globals.HLCommitPackageCommand)});
  298. //>>excludeEnd("ctx");
  299. },
  300. //>>excludeStart("ide", pragmas.excludeIdeData);
  301. args: ["anError"],
  302. source: "onPackageCommitError: anError\x0a\x09(HLPackageCommitErrorHelper on: self model)\x0a\x09\x09showHelp",
  303. referencedClasses: ["HLPackageCommitErrorHelper"],
  304. //>>excludeEnd("ide");
  305. messageSends: ["showHelp", "on:", "model"]
  306. }),
  307. $globals.HLCommitPackageCommand);
  308. $core.addMethod(
  309. $core.method({
  310. selector: "key",
  311. protocol: 'accessing',
  312. fn: function (){
  313. var self=this;
  314. return "k";
  315. },
  316. //>>excludeStart("ide", pragmas.excludeIdeData);
  317. args: [],
  318. source: "key\x0a\x09^ 'k'",
  319. referencedClasses: [],
  320. //>>excludeEnd("ide");
  321. messageSends: []
  322. }),
  323. $globals.HLCommitPackageCommand.klass);
  324. $core.addMethod(
  325. $core.method({
  326. selector: "label",
  327. protocol: 'accessing',
  328. fn: function (){
  329. var self=this;
  330. return "Commit package";
  331. },
  332. //>>excludeStart("ide", pragmas.excludeIdeData);
  333. args: [],
  334. source: "label\x0a\x09^ 'Commit package'",
  335. referencedClasses: [],
  336. //>>excludeEnd("ide");
  337. messageSends: []
  338. }),
  339. $globals.HLCommitPackageCommand.klass);
  340. $core.addClass('HLCopyCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  341. $core.addMethod(
  342. $core.method({
  343. selector: "key",
  344. protocol: 'accessing',
  345. fn: function (){
  346. var self=this;
  347. return "c";
  348. },
  349. //>>excludeStart("ide", pragmas.excludeIdeData);
  350. args: [],
  351. source: "key\x0a\x09^ 'c'",
  352. referencedClasses: [],
  353. //>>excludeEnd("ide");
  354. messageSends: []
  355. }),
  356. $globals.HLCopyCommand.klass);
  357. $core.addMethod(
  358. $core.method({
  359. selector: "label",
  360. protocol: 'accessing',
  361. fn: function (){
  362. var self=this;
  363. return "Copy";
  364. },
  365. //>>excludeStart("ide", pragmas.excludeIdeData);
  366. args: [],
  367. source: "label\x0a\x09^ 'Copy'",
  368. referencedClasses: [],
  369. //>>excludeEnd("ide");
  370. messageSends: []
  371. }),
  372. $globals.HLCopyCommand.klass);
  373. $core.addClass('HLCopyClassCommand', $globals.HLCopyCommand, [], 'Helios-Commands-Tools');
  374. $core.addMethod(
  375. $core.method({
  376. selector: "category",
  377. protocol: 'accessing',
  378. fn: function (){
  379. var self=this;
  380. return "Classes";
  381. },
  382. //>>excludeStart("ide", pragmas.excludeIdeData);
  383. args: [],
  384. source: "category\x0a\x09^ 'Classes'",
  385. referencedClasses: [],
  386. //>>excludeEnd("ide");
  387. messageSends: []
  388. }),
  389. $globals.HLCopyClassCommand);
  390. $core.addMethod(
  391. $core.method({
  392. selector: "defaultInput",
  393. protocol: 'defaults',
  394. fn: function (){
  395. var self=this;
  396. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  397. return $core.withContext(function($ctx1) {
  398. //>>excludeEnd("ctx");
  399. return $recv($recv($recv(self._model())._selectedClass())._theNonMetaClass())._name();
  400. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  401. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLCopyClassCommand)});
  402. //>>excludeEnd("ctx");
  403. },
  404. //>>excludeStart("ide", pragmas.excludeIdeData);
  405. args: [],
  406. source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
  407. referencedClasses: [],
  408. //>>excludeEnd("ide");
  409. messageSends: ["name", "theNonMetaClass", "selectedClass", "model"]
  410. }),
  411. $globals.HLCopyClassCommand);
  412. $core.addMethod(
  413. $core.method({
  414. selector: "displayLabel",
  415. protocol: 'accessing',
  416. fn: function (){
  417. var self=this;
  418. return "New class name:";
  419. },
  420. //>>excludeStart("ide", pragmas.excludeIdeData);
  421. args: [],
  422. source: "displayLabel\x0a\x09^ 'New class name:'",
  423. referencedClasses: [],
  424. //>>excludeEnd("ide");
  425. messageSends: []
  426. }),
  427. $globals.HLCopyClassCommand);
  428. $core.addMethod(
  429. $core.method({
  430. selector: "execute",
  431. protocol: 'executing',
  432. fn: function (){
  433. var self=this;
  434. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  435. return $core.withContext(function($ctx1) {
  436. //>>excludeEnd("ctx");
  437. $recv(self._model())._copyClassTo_(self._input());
  438. return self;
  439. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  440. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLCopyClassCommand)});
  441. //>>excludeEnd("ctx");
  442. },
  443. //>>excludeStart("ide", pragmas.excludeIdeData);
  444. args: [],
  445. source: "execute\x0a\x09self model copyClassTo: self input",
  446. referencedClasses: [],
  447. //>>excludeEnd("ide");
  448. messageSends: ["copyClassTo:", "model", "input"]
  449. }),
  450. $globals.HLCopyClassCommand);
  451. $core.addMethod(
  452. $core.method({
  453. selector: "isActive",
  454. protocol: 'testing',
  455. fn: function (){
  456. var self=this;
  457. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  458. return $core.withContext(function($ctx1) {
  459. //>>excludeEnd("ctx");
  460. return $recv($recv(self._model())._selectedClass())._notNil();
  461. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  462. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLCopyClassCommand)});
  463. //>>excludeEnd("ctx");
  464. },
  465. //>>excludeStart("ide", pragmas.excludeIdeData);
  466. args: [],
  467. source: "isActive\x0a\x09^ self model selectedClass notNil",
  468. referencedClasses: [],
  469. //>>excludeEnd("ide");
  470. messageSends: ["notNil", "selectedClass", "model"]
  471. }),
  472. $globals.HLCopyClassCommand);
  473. $core.addMethod(
  474. $core.method({
  475. selector: "isInputRequired",
  476. protocol: 'testing',
  477. fn: function (){
  478. var self=this;
  479. return true;
  480. },
  481. //>>excludeStart("ide", pragmas.excludeIdeData);
  482. args: [],
  483. source: "isInputRequired\x0a\x09^ true",
  484. referencedClasses: [],
  485. //>>excludeEnd("ide");
  486. messageSends: []
  487. }),
  488. $globals.HLCopyClassCommand);
  489. $core.addMethod(
  490. $core.method({
  491. selector: "key",
  492. protocol: 'accessing',
  493. fn: function (){
  494. var self=this;
  495. return "c";
  496. },
  497. //>>excludeStart("ide", pragmas.excludeIdeData);
  498. args: [],
  499. source: "key\x0a\x09^ 'c'",
  500. referencedClasses: [],
  501. //>>excludeEnd("ide");
  502. messageSends: []
  503. }),
  504. $globals.HLCopyClassCommand.klass);
  505. $core.addMethod(
  506. $core.method({
  507. selector: "label",
  508. protocol: 'accessing',
  509. fn: function (){
  510. var self=this;
  511. return "Copy class";
  512. },
  513. //>>excludeStart("ide", pragmas.excludeIdeData);
  514. args: [],
  515. source: "label\x0a\x09^ 'Copy class'",
  516. referencedClasses: [],
  517. //>>excludeEnd("ide");
  518. messageSends: []
  519. }),
  520. $globals.HLCopyClassCommand.klass);
  521. $core.addMethod(
  522. $core.method({
  523. selector: "menuLabel",
  524. protocol: 'accessing',
  525. fn: function (){
  526. var self=this;
  527. return "Copy class...";
  528. },
  529. //>>excludeStart("ide", pragmas.excludeIdeData);
  530. args: [],
  531. source: "menuLabel\x0a\x09^ 'Copy class...'",
  532. referencedClasses: [],
  533. //>>excludeEnd("ide");
  534. messageSends: []
  535. }),
  536. $globals.HLCopyClassCommand.klass);
  537. $core.addClass('HLFindCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  538. $core.addMethod(
  539. $core.method({
  540. selector: "key",
  541. protocol: 'accessing',
  542. fn: function (){
  543. var self=this;
  544. return "f";
  545. },
  546. //>>excludeStart("ide", pragmas.excludeIdeData);
  547. args: [],
  548. source: "key\x0a\x09^ 'f'",
  549. referencedClasses: [],
  550. //>>excludeEnd("ide");
  551. messageSends: []
  552. }),
  553. $globals.HLFindCommand.klass);
  554. $core.addMethod(
  555. $core.method({
  556. selector: "label",
  557. protocol: 'accessing',
  558. fn: function (){
  559. var self=this;
  560. return "Find";
  561. },
  562. //>>excludeStart("ide", pragmas.excludeIdeData);
  563. args: [],
  564. source: "label\x0a\x09^ 'Find'",
  565. referencedClasses: [],
  566. //>>excludeEnd("ide");
  567. messageSends: []
  568. }),
  569. $globals.HLFindCommand.klass);
  570. $core.addClass('HLFindClassCommand', $globals.HLFindCommand, [], 'Helios-Commands-Tools');
  571. $core.addMethod(
  572. $core.method({
  573. selector: "displayLabel",
  574. protocol: 'accessing',
  575. fn: function (){
  576. var self=this;
  577. return "select a class";
  578. },
  579. //>>excludeStart("ide", pragmas.excludeIdeData);
  580. args: [],
  581. source: "displayLabel\x0a\x09^ 'select a class'",
  582. referencedClasses: [],
  583. //>>excludeEnd("ide");
  584. messageSends: []
  585. }),
  586. $globals.HLFindClassCommand);
  587. $core.addMethod(
  588. $core.method({
  589. selector: "execute",
  590. protocol: 'executing',
  591. fn: function (){
  592. var self=this;
  593. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  594. return $core.withContext(function($ctx1) {
  595. //>>excludeEnd("ctx");
  596. $recv(self._model())._openClassNamed_(self._input());
  597. return self;
  598. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  599. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLFindClassCommand)});
  600. //>>excludeEnd("ctx");
  601. },
  602. //>>excludeStart("ide", pragmas.excludeIdeData);
  603. args: [],
  604. source: "execute\x0a\x09self model openClassNamed: self input",
  605. referencedClasses: [],
  606. //>>excludeEnd("ide");
  607. messageSends: ["openClassNamed:", "model", "input"]
  608. }),
  609. $globals.HLFindClassCommand);
  610. $core.addMethod(
  611. $core.method({
  612. selector: "inputCompletion",
  613. protocol: 'accessing',
  614. fn: function (){
  615. var self=this;
  616. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  617. return $core.withContext(function($ctx1) {
  618. //>>excludeEnd("ctx");
  619. return $recv(self._model())._availableClassNames();
  620. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  621. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLFindClassCommand)});
  622. //>>excludeEnd("ctx");
  623. },
  624. //>>excludeStart("ide", pragmas.excludeIdeData);
  625. args: [],
  626. source: "inputCompletion\x0a\x09^ self model availableClassNames",
  627. referencedClasses: [],
  628. //>>excludeEnd("ide");
  629. messageSends: ["availableClassNames", "model"]
  630. }),
  631. $globals.HLFindClassCommand);
  632. $core.addMethod(
  633. $core.method({
  634. selector: "inputLabel",
  635. protocol: 'accessing',
  636. fn: function (){
  637. var self=this;
  638. return "Find a class";
  639. },
  640. //>>excludeStart("ide", pragmas.excludeIdeData);
  641. args: [],
  642. source: "inputLabel\x0a\x09^ 'Find a class'",
  643. referencedClasses: [],
  644. //>>excludeEnd("ide");
  645. messageSends: []
  646. }),
  647. $globals.HLFindClassCommand);
  648. $core.addMethod(
  649. $core.method({
  650. selector: "isInputRequired",
  651. protocol: 'testing',
  652. fn: function (){
  653. var self=this;
  654. return true;
  655. },
  656. //>>excludeStart("ide", pragmas.excludeIdeData);
  657. args: [],
  658. source: "isInputRequired\x0a\x09^ true",
  659. referencedClasses: [],
  660. //>>excludeEnd("ide");
  661. messageSends: []
  662. }),
  663. $globals.HLFindClassCommand);
  664. $core.addMethod(
  665. $core.method({
  666. selector: "key",
  667. protocol: 'accessing',
  668. fn: function (){
  669. var self=this;
  670. return "c";
  671. },
  672. //>>excludeStart("ide", pragmas.excludeIdeData);
  673. args: [],
  674. source: "key\x0a\x09^ 'c'",
  675. referencedClasses: [],
  676. //>>excludeEnd("ide");
  677. messageSends: []
  678. }),
  679. $globals.HLFindClassCommand.klass);
  680. $core.addMethod(
  681. $core.method({
  682. selector: "label",
  683. protocol: 'accessing',
  684. fn: function (){
  685. var self=this;
  686. return "Find class";
  687. },
  688. //>>excludeStart("ide", pragmas.excludeIdeData);
  689. args: [],
  690. source: "label\x0a\x09^ 'Find class'",
  691. referencedClasses: [],
  692. //>>excludeEnd("ide");
  693. messageSends: []
  694. }),
  695. $globals.HLFindClassCommand.klass);
  696. $core.addClass('HLFindReferencesCommand', $globals.HLFindCommand, [], 'Helios-Commands-Tools');
  697. $core.addMethod(
  698. $core.method({
  699. selector: "defaultInput",
  700. protocol: 'defaults',
  701. fn: function (){
  702. var self=this;
  703. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  704. return $core.withContext(function($ctx1) {
  705. //>>excludeEnd("ctx");
  706. var $3,$2,$4,$1,$receiver;
  707. $3=self._model();
  708. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  709. $ctx1.sendIdx["model"]=1;
  710. //>>excludeEnd("ctx");
  711. $2=$recv($3)._selectedMethod();
  712. if(($receiver = $2) == null || $receiver.isNil){
  713. $4=$recv(self._model())._selectedClass();
  714. if(($receiver = $4) == null || $receiver.isNil){
  715. $1="";
  716. } else {
  717. var class_;
  718. class_=$receiver;
  719. $1=$recv($recv(class_)._theNonMetaClass())._name();
  720. };
  721. } else {
  722. var method;
  723. method=$receiver;
  724. $1=$recv(method)._selector();
  725. };
  726. return $1;
  727. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  728. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLFindReferencesCommand)});
  729. //>>excludeEnd("ctx");
  730. },
  731. //>>excludeStart("ide", pragmas.excludeIdeData);
  732. args: [],
  733. 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 ]",
  734. referencedClasses: [],
  735. //>>excludeEnd("ide");
  736. messageSends: ["ifNil:ifNotNil:", "selectedMethod", "model", "selectedClass", "name", "theNonMetaClass", "selector"]
  737. }),
  738. $globals.HLFindReferencesCommand);
  739. $core.addMethod(
  740. $core.method({
  741. selector: "displayLabel",
  742. protocol: 'accessing',
  743. fn: function (){
  744. var self=this;
  745. return "find references";
  746. },
  747. //>>excludeStart("ide", pragmas.excludeIdeData);
  748. args: [],
  749. source: "displayLabel\x0a\x09^ 'find references'",
  750. referencedClasses: [],
  751. //>>excludeEnd("ide");
  752. messageSends: []
  753. }),
  754. $globals.HLFindReferencesCommand);
  755. $core.addMethod(
  756. $core.method({
  757. selector: "execute",
  758. protocol: 'executing',
  759. fn: function (){
  760. var self=this;
  761. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  762. return $core.withContext(function($ctx1) {
  763. //>>excludeEnd("ctx");
  764. var $1;
  765. $1=$recv($globals.HLReferences)._new();
  766. $recv($1)._openAsTab();
  767. $recv($1)._search_(self._input());
  768. return self;
  769. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  770. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLFindReferencesCommand)});
  771. //>>excludeEnd("ctx");
  772. },
  773. //>>excludeStart("ide", pragmas.excludeIdeData);
  774. args: [],
  775. source: "execute\x0a\x09HLReferences new \x0a\x09\x09openAsTab;\x0a\x09\x09search: self input",
  776. referencedClasses: ["HLReferences"],
  777. //>>excludeEnd("ide");
  778. messageSends: ["openAsTab", "new", "search:", "input"]
  779. }),
  780. $globals.HLFindReferencesCommand);
  781. $core.addMethod(
  782. $core.method({
  783. selector: "inputCompletion",
  784. protocol: 'accessing',
  785. fn: function (){
  786. var self=this;
  787. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  788. return $core.withContext(function($ctx1) {
  789. //>>excludeEnd("ctx");
  790. var $2,$1;
  791. $2=self._model();
  792. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  793. $ctx1.sendIdx["model"]=1;
  794. //>>excludeEnd("ctx");
  795. $1=$recv($2)._availableClassNames();
  796. return $recv($1).__comma($recv(self._model())._allSelectors());
  797. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  798. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLFindReferencesCommand)});
  799. //>>excludeEnd("ctx");
  800. },
  801. //>>excludeStart("ide", pragmas.excludeIdeData);
  802. args: [],
  803. source: "inputCompletion\x0a\x09^ self model availableClassNames, self model allSelectors",
  804. referencedClasses: [],
  805. //>>excludeEnd("ide");
  806. messageSends: [",", "availableClassNames", "model", "allSelectors"]
  807. }),
  808. $globals.HLFindReferencesCommand);
  809. $core.addMethod(
  810. $core.method({
  811. selector: "inputLabel",
  812. protocol: 'accessing',
  813. fn: function (){
  814. var self=this;
  815. return "Find references of";
  816. },
  817. //>>excludeStart("ide", pragmas.excludeIdeData);
  818. args: [],
  819. source: "inputLabel\x0a\x09^ 'Find references of'",
  820. referencedClasses: [],
  821. //>>excludeEnd("ide");
  822. messageSends: []
  823. }),
  824. $globals.HLFindReferencesCommand);
  825. $core.addMethod(
  826. $core.method({
  827. selector: "isInputRequired",
  828. protocol: 'testing',
  829. fn: function (){
  830. var self=this;
  831. return true;
  832. },
  833. //>>excludeStart("ide", pragmas.excludeIdeData);
  834. args: [],
  835. source: "isInputRequired\x0a\x09^ true",
  836. referencedClasses: [],
  837. //>>excludeEnd("ide");
  838. messageSends: []
  839. }),
  840. $globals.HLFindReferencesCommand);
  841. $core.addMethod(
  842. $core.method({
  843. selector: "key",
  844. protocol: 'accessing',
  845. fn: function (){
  846. var self=this;
  847. return "r";
  848. },
  849. //>>excludeStart("ide", pragmas.excludeIdeData);
  850. args: [],
  851. source: "key\x0a\x09^ 'r'",
  852. referencedClasses: [],
  853. //>>excludeEnd("ide");
  854. messageSends: []
  855. }),
  856. $globals.HLFindReferencesCommand.klass);
  857. $core.addMethod(
  858. $core.method({
  859. selector: "label",
  860. protocol: 'accessing',
  861. fn: function (){
  862. var self=this;
  863. return "Find references";
  864. },
  865. //>>excludeStart("ide", pragmas.excludeIdeData);
  866. args: [],
  867. source: "label\x0a\x09^ 'Find references'",
  868. referencedClasses: [],
  869. //>>excludeEnd("ide");
  870. messageSends: []
  871. }),
  872. $globals.HLFindReferencesCommand.klass);
  873. $core.addClass('HLMoveToCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  874. $core.addMethod(
  875. $core.method({
  876. selector: "key",
  877. protocol: 'accessing',
  878. fn: function (){
  879. var self=this;
  880. return "m";
  881. },
  882. //>>excludeStart("ide", pragmas.excludeIdeData);
  883. args: [],
  884. source: "key\x0a\x09^ 'm'",
  885. referencedClasses: [],
  886. //>>excludeEnd("ide");
  887. messageSends: []
  888. }),
  889. $globals.HLMoveToCommand.klass);
  890. $core.addMethod(
  891. $core.method({
  892. selector: "label",
  893. protocol: 'accessing',
  894. fn: function (){
  895. var self=this;
  896. return "Move";
  897. },
  898. //>>excludeStart("ide", pragmas.excludeIdeData);
  899. args: [],
  900. source: "label\x0a\x09^ 'Move'",
  901. referencedClasses: [],
  902. //>>excludeEnd("ide");
  903. messageSends: []
  904. }),
  905. $globals.HLMoveToCommand.klass);
  906. $core.addClass('HLMoveClassToCommand', $globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
  907. $core.addMethod(
  908. $core.method({
  909. selector: "isActive",
  910. protocol: 'testing',
  911. fn: function (){
  912. var self=this;
  913. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  914. return $core.withContext(function($ctx1) {
  915. //>>excludeEnd("ctx");
  916. return $recv($recv(self._model())._selectedClass())._notNil();
  917. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  918. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLMoveClassToCommand)});
  919. //>>excludeEnd("ctx");
  920. },
  921. //>>excludeStart("ide", pragmas.excludeIdeData);
  922. args: [],
  923. source: "isActive\x0a\x09^ self model selectedClass notNil",
  924. referencedClasses: [],
  925. //>>excludeEnd("ide");
  926. messageSends: ["notNil", "selectedClass", "model"]
  927. }),
  928. $globals.HLMoveClassToCommand);
  929. $core.addMethod(
  930. $core.method({
  931. selector: "key",
  932. protocol: 'accessing',
  933. fn: function (){
  934. var self=this;
  935. return "c";
  936. },
  937. //>>excludeStart("ide", pragmas.excludeIdeData);
  938. args: [],
  939. source: "key\x0a\x09^ 'c'",
  940. referencedClasses: [],
  941. //>>excludeEnd("ide");
  942. messageSends: []
  943. }),
  944. $globals.HLMoveClassToCommand.klass);
  945. $core.addMethod(
  946. $core.method({
  947. selector: "label",
  948. protocol: 'accessing',
  949. fn: function (){
  950. var self=this;
  951. return "Move class";
  952. },
  953. //>>excludeStart("ide", pragmas.excludeIdeData);
  954. args: [],
  955. source: "label\x0a\x09^ 'Move class'",
  956. referencedClasses: [],
  957. //>>excludeEnd("ide");
  958. messageSends: []
  959. }),
  960. $globals.HLMoveClassToCommand.klass);
  961. $core.addClass('HLMoveClassToPackageCommand', $globals.HLMoveClassToCommand, [], 'Helios-Commands-Tools');
  962. $core.addMethod(
  963. $core.method({
  964. selector: "category",
  965. protocol: 'accessing',
  966. fn: function (){
  967. var self=this;
  968. return "Classes";
  969. },
  970. //>>excludeStart("ide", pragmas.excludeIdeData);
  971. args: [],
  972. source: "category\x0a\x09^ 'Classes'",
  973. referencedClasses: [],
  974. //>>excludeEnd("ide");
  975. messageSends: []
  976. }),
  977. $globals.HLMoveClassToPackageCommand);
  978. $core.addMethod(
  979. $core.method({
  980. selector: "displayLabel",
  981. protocol: 'accessing',
  982. fn: function (){
  983. var self=this;
  984. return "select a package";
  985. },
  986. //>>excludeStart("ide", pragmas.excludeIdeData);
  987. args: [],
  988. source: "displayLabel\x0a\x09^ 'select a package'",
  989. referencedClasses: [],
  990. //>>excludeEnd("ide");
  991. messageSends: []
  992. }),
  993. $globals.HLMoveClassToPackageCommand);
  994. $core.addMethod(
  995. $core.method({
  996. selector: "execute",
  997. protocol: 'executing',
  998. fn: function (){
  999. var self=this;
  1000. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1001. return $core.withContext(function($ctx1) {
  1002. //>>excludeEnd("ctx");
  1003. $recv(self._model())._moveClassToPackage_(self._input());
  1004. return self;
  1005. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1006. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLMoveClassToPackageCommand)});
  1007. //>>excludeEnd("ctx");
  1008. },
  1009. //>>excludeStart("ide", pragmas.excludeIdeData);
  1010. args: [],
  1011. source: "execute\x0a\x09self model moveClassToPackage: self input",
  1012. referencedClasses: [],
  1013. //>>excludeEnd("ide");
  1014. messageSends: ["moveClassToPackage:", "model", "input"]
  1015. }),
  1016. $globals.HLMoveClassToPackageCommand);
  1017. $core.addMethod(
  1018. $core.method({
  1019. selector: "inputCompletion",
  1020. protocol: 'accessing',
  1021. fn: function (){
  1022. var self=this;
  1023. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1024. return $core.withContext(function($ctx1) {
  1025. //>>excludeEnd("ctx");
  1026. return $recv(self._model())._availablePackageNames();
  1027. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1028. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLMoveClassToPackageCommand)});
  1029. //>>excludeEnd("ctx");
  1030. },
  1031. //>>excludeStart("ide", pragmas.excludeIdeData);
  1032. args: [],
  1033. source: "inputCompletion\x0a\x09^ self model availablePackageNames",
  1034. referencedClasses: [],
  1035. //>>excludeEnd("ide");
  1036. messageSends: ["availablePackageNames", "model"]
  1037. }),
  1038. $globals.HLMoveClassToPackageCommand);
  1039. $core.addMethod(
  1040. $core.method({
  1041. selector: "inputLabel",
  1042. protocol: 'accessing',
  1043. fn: function (){
  1044. var self=this;
  1045. return "Move class to package:";
  1046. },
  1047. //>>excludeStart("ide", pragmas.excludeIdeData);
  1048. args: [],
  1049. source: "inputLabel\x0a\x09^ 'Move class to package:'",
  1050. referencedClasses: [],
  1051. //>>excludeEnd("ide");
  1052. messageSends: []
  1053. }),
  1054. $globals.HLMoveClassToPackageCommand);
  1055. $core.addMethod(
  1056. $core.method({
  1057. selector: "isInputRequired",
  1058. protocol: 'testing',
  1059. fn: function (){
  1060. var self=this;
  1061. return true;
  1062. },
  1063. //>>excludeStart("ide", pragmas.excludeIdeData);
  1064. args: [],
  1065. source: "isInputRequired\x0a\x09^ true",
  1066. referencedClasses: [],
  1067. //>>excludeEnd("ide");
  1068. messageSends: []
  1069. }),
  1070. $globals.HLMoveClassToPackageCommand);
  1071. $core.addMethod(
  1072. $core.method({
  1073. selector: "key",
  1074. protocol: 'accessing',
  1075. fn: function (){
  1076. var self=this;
  1077. return "p";
  1078. },
  1079. //>>excludeStart("ide", pragmas.excludeIdeData);
  1080. args: [],
  1081. source: "key\x0a\x09^ 'p'",
  1082. referencedClasses: [],
  1083. //>>excludeEnd("ide");
  1084. messageSends: []
  1085. }),
  1086. $globals.HLMoveClassToPackageCommand.klass);
  1087. $core.addMethod(
  1088. $core.method({
  1089. selector: "label",
  1090. protocol: 'accessing',
  1091. fn: function (){
  1092. var self=this;
  1093. return "Move class to package";
  1094. },
  1095. //>>excludeStart("ide", pragmas.excludeIdeData);
  1096. args: [],
  1097. source: "label\x0a\x09^ 'Move class to package'",
  1098. referencedClasses: [],
  1099. //>>excludeEnd("ide");
  1100. messageSends: []
  1101. }),
  1102. $globals.HLMoveClassToPackageCommand.klass);
  1103. $core.addMethod(
  1104. $core.method({
  1105. selector: "menuLabel",
  1106. protocol: 'accessing',
  1107. fn: function (){
  1108. var self=this;
  1109. return "Move to package...";
  1110. },
  1111. //>>excludeStart("ide", pragmas.excludeIdeData);
  1112. args: [],
  1113. source: "menuLabel\x09\x0a\x09^ 'Move to package...'",
  1114. referencedClasses: [],
  1115. //>>excludeEnd("ide");
  1116. messageSends: []
  1117. }),
  1118. $globals.HLMoveClassToPackageCommand.klass);
  1119. $core.addClass('HLMoveMethodToCommand', $globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
  1120. $core.addMethod(
  1121. $core.method({
  1122. selector: "category",
  1123. protocol: 'accessing',
  1124. fn: function (){
  1125. var self=this;
  1126. return "Methods";
  1127. },
  1128. //>>excludeStart("ide", pragmas.excludeIdeData);
  1129. args: [],
  1130. source: "category\x0a\x09^ 'Methods'",
  1131. referencedClasses: [],
  1132. //>>excludeEnd("ide");
  1133. messageSends: []
  1134. }),
  1135. $globals.HLMoveMethodToCommand);
  1136. $core.addMethod(
  1137. $core.method({
  1138. selector: "isActive",
  1139. protocol: 'testing',
  1140. fn: function (){
  1141. var self=this;
  1142. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1143. return $core.withContext(function($ctx1) {
  1144. //>>excludeEnd("ctx");
  1145. return $recv($recv(self._model())._selectedMethod())._notNil();
  1146. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1147. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLMoveMethodToCommand)});
  1148. //>>excludeEnd("ctx");
  1149. },
  1150. //>>excludeStart("ide", pragmas.excludeIdeData);
  1151. args: [],
  1152. source: "isActive\x0a\x09^ self model selectedMethod notNil",
  1153. referencedClasses: [],
  1154. //>>excludeEnd("ide");
  1155. messageSends: ["notNil", "selectedMethod", "model"]
  1156. }),
  1157. $globals.HLMoveMethodToCommand);
  1158. $core.addMethod(
  1159. $core.method({
  1160. selector: "key",
  1161. protocol: 'accessing',
  1162. fn: function (){
  1163. var self=this;
  1164. return "m";
  1165. },
  1166. //>>excludeStart("ide", pragmas.excludeIdeData);
  1167. args: [],
  1168. source: "key\x0a\x09^ 'm'",
  1169. referencedClasses: [],
  1170. //>>excludeEnd("ide");
  1171. messageSends: []
  1172. }),
  1173. $globals.HLMoveMethodToCommand.klass);
  1174. $core.addMethod(
  1175. $core.method({
  1176. selector: "label",
  1177. protocol: 'accessing',
  1178. fn: function (){
  1179. var self=this;
  1180. return "Move method";
  1181. },
  1182. //>>excludeStart("ide", pragmas.excludeIdeData);
  1183. args: [],
  1184. source: "label\x0a\x09^ 'Move method'",
  1185. referencedClasses: [],
  1186. //>>excludeEnd("ide");
  1187. messageSends: []
  1188. }),
  1189. $globals.HLMoveMethodToCommand.klass);
  1190. $core.addClass('HLMoveMethodToClassCommand', $globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
  1191. $core.addMethod(
  1192. $core.method({
  1193. selector: "displayLabel",
  1194. protocol: 'accessing',
  1195. fn: function (){
  1196. var self=this;
  1197. return "select a class";
  1198. },
  1199. //>>excludeStart("ide", pragmas.excludeIdeData);
  1200. args: [],
  1201. source: "displayLabel\x0a\x09^ 'select a class'",
  1202. referencedClasses: [],
  1203. //>>excludeEnd("ide");
  1204. messageSends: []
  1205. }),
  1206. $globals.HLMoveMethodToClassCommand);
  1207. $core.addMethod(
  1208. $core.method({
  1209. selector: "execute",
  1210. protocol: 'executing',
  1211. fn: function (){
  1212. var self=this;
  1213. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1214. return $core.withContext(function($ctx1) {
  1215. //>>excludeEnd("ctx");
  1216. $recv(self._model())._moveMethodToClass_(self._input());
  1217. return self;
  1218. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1219. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLMoveMethodToClassCommand)});
  1220. //>>excludeEnd("ctx");
  1221. },
  1222. //>>excludeStart("ide", pragmas.excludeIdeData);
  1223. args: [],
  1224. source: "execute\x0a\x09self model moveMethodToClass: self input",
  1225. referencedClasses: [],
  1226. //>>excludeEnd("ide");
  1227. messageSends: ["moveMethodToClass:", "model", "input"]
  1228. }),
  1229. $globals.HLMoveMethodToClassCommand);
  1230. $core.addMethod(
  1231. $core.method({
  1232. selector: "inputCompletion",
  1233. protocol: 'accessing',
  1234. fn: function (){
  1235. var self=this;
  1236. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1237. return $core.withContext(function($ctx1) {
  1238. //>>excludeEnd("ctx");
  1239. return $recv(self._model())._availableClassNames();
  1240. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1241. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLMoveMethodToClassCommand)});
  1242. //>>excludeEnd("ctx");
  1243. },
  1244. //>>excludeStart("ide", pragmas.excludeIdeData);
  1245. args: [],
  1246. source: "inputCompletion\x0a\x09^ self model availableClassNames",
  1247. referencedClasses: [],
  1248. //>>excludeEnd("ide");
  1249. messageSends: ["availableClassNames", "model"]
  1250. }),
  1251. $globals.HLMoveMethodToClassCommand);
  1252. $core.addMethod(
  1253. $core.method({
  1254. selector: "inputLabel",
  1255. protocol: 'accessing',
  1256. fn: function (){
  1257. var self=this;
  1258. return "Move method to class:";
  1259. },
  1260. //>>excludeStart("ide", pragmas.excludeIdeData);
  1261. args: [],
  1262. source: "inputLabel\x0a\x09^ 'Move method to class:'",
  1263. referencedClasses: [],
  1264. //>>excludeEnd("ide");
  1265. messageSends: []
  1266. }),
  1267. $globals.HLMoveMethodToClassCommand);
  1268. $core.addMethod(
  1269. $core.method({
  1270. selector: "isInputRequired",
  1271. protocol: 'testing',
  1272. fn: function (){
  1273. var self=this;
  1274. return true;
  1275. },
  1276. //>>excludeStart("ide", pragmas.excludeIdeData);
  1277. args: [],
  1278. source: "isInputRequired\x0a\x09^ true",
  1279. referencedClasses: [],
  1280. //>>excludeEnd("ide");
  1281. messageSends: []
  1282. }),
  1283. $globals.HLMoveMethodToClassCommand);
  1284. $core.addMethod(
  1285. $core.method({
  1286. selector: "key",
  1287. protocol: 'accessing',
  1288. fn: function (){
  1289. var self=this;
  1290. return "c";
  1291. },
  1292. //>>excludeStart("ide", pragmas.excludeIdeData);
  1293. args: [],
  1294. source: "key\x0a\x09^ 'c'",
  1295. referencedClasses: [],
  1296. //>>excludeEnd("ide");
  1297. messageSends: []
  1298. }),
  1299. $globals.HLMoveMethodToClassCommand.klass);
  1300. $core.addMethod(
  1301. $core.method({
  1302. selector: "label",
  1303. protocol: 'accessing',
  1304. fn: function (){
  1305. var self=this;
  1306. return "Move method to class";
  1307. },
  1308. //>>excludeStart("ide", pragmas.excludeIdeData);
  1309. args: [],
  1310. source: "label\x09\x0a\x09^ 'Move method to class'",
  1311. referencedClasses: [],
  1312. //>>excludeEnd("ide");
  1313. messageSends: []
  1314. }),
  1315. $globals.HLMoveMethodToClassCommand.klass);
  1316. $core.addMethod(
  1317. $core.method({
  1318. selector: "menuLabel",
  1319. protocol: 'accessing',
  1320. fn: function (){
  1321. var self=this;
  1322. return "Move to class...";
  1323. },
  1324. //>>excludeStart("ide", pragmas.excludeIdeData);
  1325. args: [],
  1326. source: "menuLabel\x09\x0a\x09^ 'Move to class...'",
  1327. referencedClasses: [],
  1328. //>>excludeEnd("ide");
  1329. messageSends: []
  1330. }),
  1331. $globals.HLMoveMethodToClassCommand.klass);
  1332. $core.addClass('HLMoveMethodToProtocolCommand', $globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
  1333. $core.addMethod(
  1334. $core.method({
  1335. selector: "displayLabel",
  1336. protocol: 'accessing',
  1337. fn: function (){
  1338. var self=this;
  1339. return "select a protocol";
  1340. },
  1341. //>>excludeStart("ide", pragmas.excludeIdeData);
  1342. args: [],
  1343. source: "displayLabel\x0a\x09^ 'select a protocol'",
  1344. referencedClasses: [],
  1345. //>>excludeEnd("ide");
  1346. messageSends: []
  1347. }),
  1348. $globals.HLMoveMethodToProtocolCommand);
  1349. $core.addMethod(
  1350. $core.method({
  1351. selector: "execute",
  1352. protocol: 'executing',
  1353. fn: function (){
  1354. var self=this;
  1355. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1356. return $core.withContext(function($ctx1) {
  1357. //>>excludeEnd("ctx");
  1358. $recv(self._model())._moveMethodToProtocol_(self._input());
  1359. return self;
  1360. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1361. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLMoveMethodToProtocolCommand)});
  1362. //>>excludeEnd("ctx");
  1363. },
  1364. //>>excludeStart("ide", pragmas.excludeIdeData);
  1365. args: [],
  1366. source: "execute\x0a\x09self model moveMethodToProtocol: self input",
  1367. referencedClasses: [],
  1368. //>>excludeEnd("ide");
  1369. messageSends: ["moveMethodToProtocol:", "model", "input"]
  1370. }),
  1371. $globals.HLMoveMethodToProtocolCommand);
  1372. $core.addMethod(
  1373. $core.method({
  1374. selector: "inputCompletion",
  1375. protocol: 'accessing',
  1376. fn: function (){
  1377. var self=this;
  1378. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1379. return $core.withContext(function($ctx1) {
  1380. //>>excludeEnd("ctx");
  1381. return $recv(self._model())._availableProtocols();
  1382. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1383. }, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLMoveMethodToProtocolCommand)});
  1384. //>>excludeEnd("ctx");
  1385. },
  1386. //>>excludeStart("ide", pragmas.excludeIdeData);
  1387. args: [],
  1388. source: "inputCompletion\x0a\x09^ self model availableProtocols",
  1389. referencedClasses: [],
  1390. //>>excludeEnd("ide");
  1391. messageSends: ["availableProtocols", "model"]
  1392. }),
  1393. $globals.HLMoveMethodToProtocolCommand);
  1394. $core.addMethod(
  1395. $core.method({
  1396. selector: "inputLabel",
  1397. protocol: 'accessing',
  1398. fn: function (){
  1399. var self=this;
  1400. return "Move method to a protocol:";
  1401. },
  1402. //>>excludeStart("ide", pragmas.excludeIdeData);
  1403. args: [],
  1404. source: "inputLabel\x0a\x09^ 'Move method to a protocol:'",
  1405. referencedClasses: [],
  1406. //>>excludeEnd("ide");
  1407. messageSends: []
  1408. }),
  1409. $globals.HLMoveMethodToProtocolCommand);
  1410. $core.addMethod(
  1411. $core.method({
  1412. selector: "isInputRequired",
  1413. protocol: 'testing',
  1414. fn: function (){
  1415. var self=this;
  1416. return true;
  1417. },
  1418. //>>excludeStart("ide", pragmas.excludeIdeData);
  1419. args: [],
  1420. source: "isInputRequired\x0a\x09^ true",
  1421. referencedClasses: [],
  1422. //>>excludeEnd("ide");
  1423. messageSends: []
  1424. }),
  1425. $globals.HLMoveMethodToProtocolCommand);
  1426. $core.addMethod(
  1427. $core.method({
  1428. selector: "key",
  1429. protocol: 'accessing',
  1430. fn: function (){
  1431. var self=this;
  1432. return "t";
  1433. },
  1434. //>>excludeStart("ide", pragmas.excludeIdeData);
  1435. args: [],
  1436. source: "key\x0a\x09^ 't'",
  1437. referencedClasses: [],
  1438. //>>excludeEnd("ide");
  1439. messageSends: []
  1440. }),
  1441. $globals.HLMoveMethodToProtocolCommand.klass);
  1442. $core.addMethod(
  1443. $core.method({
  1444. selector: "label",
  1445. protocol: 'accessing',
  1446. fn: function (){
  1447. var self=this;
  1448. return "Move method to protocol";
  1449. },
  1450. //>>excludeStart("ide", pragmas.excludeIdeData);
  1451. args: [],
  1452. source: "label\x0a\x09^ 'Move method to protocol'",
  1453. referencedClasses: [],
  1454. //>>excludeEnd("ide");
  1455. messageSends: []
  1456. }),
  1457. $globals.HLMoveMethodToProtocolCommand.klass);
  1458. $core.addMethod(
  1459. $core.method({
  1460. selector: "menuLabel",
  1461. protocol: 'accessing',
  1462. fn: function (){
  1463. var self=this;
  1464. return "Move to protocol...";
  1465. },
  1466. //>>excludeStart("ide", pragmas.excludeIdeData);
  1467. args: [],
  1468. source: "menuLabel\x0a\x09^ 'Move to protocol...'",
  1469. referencedClasses: [],
  1470. //>>excludeEnd("ide");
  1471. messageSends: []
  1472. }),
  1473. $globals.HLMoveMethodToProtocolCommand.klass);
  1474. $core.addClass('HLRemoveCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  1475. $core.addMethod(
  1476. $core.method({
  1477. selector: "key",
  1478. protocol: 'accessing',
  1479. fn: function (){
  1480. var self=this;
  1481. return "x";
  1482. },
  1483. //>>excludeStart("ide", pragmas.excludeIdeData);
  1484. args: [],
  1485. source: "key\x0a\x09^ 'x'",
  1486. referencedClasses: [],
  1487. //>>excludeEnd("ide");
  1488. messageSends: []
  1489. }),
  1490. $globals.HLRemoveCommand.klass);
  1491. $core.addMethod(
  1492. $core.method({
  1493. selector: "label",
  1494. protocol: 'accessing',
  1495. fn: function (){
  1496. var self=this;
  1497. return "Remove";
  1498. },
  1499. //>>excludeStart("ide", pragmas.excludeIdeData);
  1500. args: [],
  1501. source: "label\x0a\x09^ 'Remove'",
  1502. referencedClasses: [],
  1503. //>>excludeEnd("ide");
  1504. messageSends: []
  1505. }),
  1506. $globals.HLRemoveCommand.klass);
  1507. $core.addClass('HLRemoveClassCommand', $globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
  1508. $core.addMethod(
  1509. $core.method({
  1510. selector: "category",
  1511. protocol: 'accessing',
  1512. fn: function (){
  1513. var self=this;
  1514. return "Classes";
  1515. },
  1516. //>>excludeStart("ide", pragmas.excludeIdeData);
  1517. args: [],
  1518. source: "category\x0a\x09^ 'Classes'",
  1519. referencedClasses: [],
  1520. //>>excludeEnd("ide");
  1521. messageSends: []
  1522. }),
  1523. $globals.HLRemoveClassCommand);
  1524. $core.addMethod(
  1525. $core.method({
  1526. selector: "execute",
  1527. protocol: 'executing',
  1528. fn: function (){
  1529. var self=this;
  1530. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1531. return $core.withContext(function($ctx1) {
  1532. //>>excludeEnd("ctx");
  1533. $recv(self._model())._removeClass();
  1534. return self;
  1535. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1536. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRemoveClassCommand)});
  1537. //>>excludeEnd("ctx");
  1538. },
  1539. //>>excludeStart("ide", pragmas.excludeIdeData);
  1540. args: [],
  1541. source: "execute\x0a\x09self model removeClass",
  1542. referencedClasses: [],
  1543. //>>excludeEnd("ide");
  1544. messageSends: ["removeClass", "model"]
  1545. }),
  1546. $globals.HLRemoveClassCommand);
  1547. $core.addMethod(
  1548. $core.method({
  1549. selector: "isActive",
  1550. protocol: 'testing',
  1551. fn: function (){
  1552. var self=this;
  1553. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1554. return $core.withContext(function($ctx1) {
  1555. //>>excludeEnd("ctx");
  1556. return $recv($recv(self._model())._selectedClass())._notNil();
  1557. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1558. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRemoveClassCommand)});
  1559. //>>excludeEnd("ctx");
  1560. },
  1561. //>>excludeStart("ide", pragmas.excludeIdeData);
  1562. args: [],
  1563. source: "isActive\x0a\x09^ self model selectedClass notNil",
  1564. referencedClasses: [],
  1565. //>>excludeEnd("ide");
  1566. messageSends: ["notNil", "selectedClass", "model"]
  1567. }),
  1568. $globals.HLRemoveClassCommand);
  1569. $core.addMethod(
  1570. $core.method({
  1571. selector: "key",
  1572. protocol: 'accessing',
  1573. fn: function (){
  1574. var self=this;
  1575. return "c";
  1576. },
  1577. //>>excludeStart("ide", pragmas.excludeIdeData);
  1578. args: [],
  1579. source: "key\x0a\x09^ 'c'",
  1580. referencedClasses: [],
  1581. //>>excludeEnd("ide");
  1582. messageSends: []
  1583. }),
  1584. $globals.HLRemoveClassCommand.klass);
  1585. $core.addMethod(
  1586. $core.method({
  1587. selector: "label",
  1588. protocol: 'accessing',
  1589. fn: function (){
  1590. var self=this;
  1591. return "Remove class";
  1592. },
  1593. //>>excludeStart("ide", pragmas.excludeIdeData);
  1594. args: [],
  1595. source: "label\x0a\x09^ 'Remove class'",
  1596. referencedClasses: [],
  1597. //>>excludeEnd("ide");
  1598. messageSends: []
  1599. }),
  1600. $globals.HLRemoveClassCommand.klass);
  1601. $core.addMethod(
  1602. $core.method({
  1603. selector: "menuLabel",
  1604. protocol: 'accessing',
  1605. fn: function (){
  1606. var self=this;
  1607. return "Remove class";
  1608. },
  1609. //>>excludeStart("ide", pragmas.excludeIdeData);
  1610. args: [],
  1611. source: "menuLabel\x0a\x09^ 'Remove class'",
  1612. referencedClasses: [],
  1613. //>>excludeEnd("ide");
  1614. messageSends: []
  1615. }),
  1616. $globals.HLRemoveClassCommand.klass);
  1617. $core.addClass('HLRemoveMethodCommand', $globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
  1618. $core.addMethod(
  1619. $core.method({
  1620. selector: "category",
  1621. protocol: 'accessing',
  1622. fn: function (){
  1623. var self=this;
  1624. return "Methods";
  1625. },
  1626. //>>excludeStart("ide", pragmas.excludeIdeData);
  1627. args: [],
  1628. source: "category\x0a\x09^ 'Methods'",
  1629. referencedClasses: [],
  1630. //>>excludeEnd("ide");
  1631. messageSends: []
  1632. }),
  1633. $globals.HLRemoveMethodCommand);
  1634. $core.addMethod(
  1635. $core.method({
  1636. selector: "execute",
  1637. protocol: 'executing',
  1638. fn: function (){
  1639. var self=this;
  1640. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1641. return $core.withContext(function($ctx1) {
  1642. //>>excludeEnd("ctx");
  1643. $recv(self._model())._removeMethod();
  1644. return self;
  1645. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1646. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRemoveMethodCommand)});
  1647. //>>excludeEnd("ctx");
  1648. },
  1649. //>>excludeStart("ide", pragmas.excludeIdeData);
  1650. args: [],
  1651. source: "execute\x0a\x09self model removeMethod",
  1652. referencedClasses: [],
  1653. //>>excludeEnd("ide");
  1654. messageSends: ["removeMethod", "model"]
  1655. }),
  1656. $globals.HLRemoveMethodCommand);
  1657. $core.addMethod(
  1658. $core.method({
  1659. selector: "isActive",
  1660. protocol: 'testing',
  1661. fn: function (){
  1662. var self=this;
  1663. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1664. return $core.withContext(function($ctx1) {
  1665. //>>excludeEnd("ctx");
  1666. return $recv($recv(self._model())._selectedMethod())._notNil();
  1667. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1668. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRemoveMethodCommand)});
  1669. //>>excludeEnd("ctx");
  1670. },
  1671. //>>excludeStart("ide", pragmas.excludeIdeData);
  1672. args: [],
  1673. source: "isActive\x0a\x09^ self model selectedMethod notNil",
  1674. referencedClasses: [],
  1675. //>>excludeEnd("ide");
  1676. messageSends: ["notNil", "selectedMethod", "model"]
  1677. }),
  1678. $globals.HLRemoveMethodCommand);
  1679. $core.addMethod(
  1680. $core.method({
  1681. selector: "key",
  1682. protocol: 'accessing',
  1683. fn: function (){
  1684. var self=this;
  1685. return "m";
  1686. },
  1687. //>>excludeStart("ide", pragmas.excludeIdeData);
  1688. args: [],
  1689. source: "key\x0a\x09^ 'm'",
  1690. referencedClasses: [],
  1691. //>>excludeEnd("ide");
  1692. messageSends: []
  1693. }),
  1694. $globals.HLRemoveMethodCommand.klass);
  1695. $core.addMethod(
  1696. $core.method({
  1697. selector: "label",
  1698. protocol: 'accessing',
  1699. fn: function (){
  1700. var self=this;
  1701. return "Remove method";
  1702. },
  1703. //>>excludeStart("ide", pragmas.excludeIdeData);
  1704. args: [],
  1705. source: "label\x0a\x09^ 'Remove method'",
  1706. referencedClasses: [],
  1707. //>>excludeEnd("ide");
  1708. messageSends: []
  1709. }),
  1710. $globals.HLRemoveMethodCommand.klass);
  1711. $core.addMethod(
  1712. $core.method({
  1713. selector: "menuLabel",
  1714. protocol: 'accessing',
  1715. fn: function (){
  1716. var self=this;
  1717. return "Remove method";
  1718. },
  1719. //>>excludeStart("ide", pragmas.excludeIdeData);
  1720. args: [],
  1721. source: "menuLabel\x0a\x09^ 'Remove method'",
  1722. referencedClasses: [],
  1723. //>>excludeEnd("ide");
  1724. messageSends: []
  1725. }),
  1726. $globals.HLRemoveMethodCommand.klass);
  1727. $core.addClass('HLRemoveProtocolCommand', $globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
  1728. $core.addMethod(
  1729. $core.method({
  1730. selector: "category",
  1731. protocol: 'accessing',
  1732. fn: function (){
  1733. var self=this;
  1734. return "Protocols";
  1735. },
  1736. //>>excludeStart("ide", pragmas.excludeIdeData);
  1737. args: [],
  1738. source: "category\x0a\x09^ 'Protocols'",
  1739. referencedClasses: [],
  1740. //>>excludeEnd("ide");
  1741. messageSends: []
  1742. }),
  1743. $globals.HLRemoveProtocolCommand);
  1744. $core.addMethod(
  1745. $core.method({
  1746. selector: "execute",
  1747. protocol: 'executing',
  1748. fn: function (){
  1749. var self=this;
  1750. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1751. return $core.withContext(function($ctx1) {
  1752. //>>excludeEnd("ctx");
  1753. $recv(self._model())._removeProtocol();
  1754. return self;
  1755. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1756. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRemoveProtocolCommand)});
  1757. //>>excludeEnd("ctx");
  1758. },
  1759. //>>excludeStart("ide", pragmas.excludeIdeData);
  1760. args: [],
  1761. source: "execute\x0a\x09self model removeProtocol",
  1762. referencedClasses: [],
  1763. //>>excludeEnd("ide");
  1764. messageSends: ["removeProtocol", "model"]
  1765. }),
  1766. $globals.HLRemoveProtocolCommand);
  1767. $core.addMethod(
  1768. $core.method({
  1769. selector: "isActive",
  1770. protocol: 'testing',
  1771. fn: function (){
  1772. var self=this;
  1773. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1774. return $core.withContext(function($ctx1) {
  1775. //>>excludeEnd("ctx");
  1776. return $recv($recv(self._model())._selectedProtocol())._notNil();
  1777. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1778. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRemoveProtocolCommand)});
  1779. //>>excludeEnd("ctx");
  1780. },
  1781. //>>excludeStart("ide", pragmas.excludeIdeData);
  1782. args: [],
  1783. source: "isActive\x0a\x09^ self model selectedProtocol notNil",
  1784. referencedClasses: [],
  1785. //>>excludeEnd("ide");
  1786. messageSends: ["notNil", "selectedProtocol", "model"]
  1787. }),
  1788. $globals.HLRemoveProtocolCommand);
  1789. $core.addMethod(
  1790. $core.method({
  1791. selector: "key",
  1792. protocol: 'accessing',
  1793. fn: function (){
  1794. var self=this;
  1795. return "t";
  1796. },
  1797. //>>excludeStart("ide", pragmas.excludeIdeData);
  1798. args: [],
  1799. source: "key\x0a\x09^ 't'",
  1800. referencedClasses: [],
  1801. //>>excludeEnd("ide");
  1802. messageSends: []
  1803. }),
  1804. $globals.HLRemoveProtocolCommand.klass);
  1805. $core.addMethod(
  1806. $core.method({
  1807. selector: "label",
  1808. protocol: 'accessing',
  1809. fn: function (){
  1810. var self=this;
  1811. return "Remove protocol";
  1812. },
  1813. //>>excludeStart("ide", pragmas.excludeIdeData);
  1814. args: [],
  1815. source: "label\x0a\x09^ 'Remove protocol'",
  1816. referencedClasses: [],
  1817. //>>excludeEnd("ide");
  1818. messageSends: []
  1819. }),
  1820. $globals.HLRemoveProtocolCommand.klass);
  1821. $core.addMethod(
  1822. $core.method({
  1823. selector: "menuLabel",
  1824. protocol: 'accessing',
  1825. fn: function (){
  1826. var self=this;
  1827. return "Remove protocol";
  1828. },
  1829. //>>excludeStart("ide", pragmas.excludeIdeData);
  1830. args: [],
  1831. source: "menuLabel\x0a\x09^ 'Remove protocol'",
  1832. referencedClasses: [],
  1833. //>>excludeEnd("ide");
  1834. messageSends: []
  1835. }),
  1836. $globals.HLRemoveProtocolCommand.klass);
  1837. $core.addClass('HLRenameCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
  1838. $core.addMethod(
  1839. $core.method({
  1840. selector: "key",
  1841. protocol: 'accessing',
  1842. fn: function (){
  1843. var self=this;
  1844. return "r";
  1845. },
  1846. //>>excludeStart("ide", pragmas.excludeIdeData);
  1847. args: [],
  1848. source: "key\x0a\x09^ 'r'",
  1849. referencedClasses: [],
  1850. //>>excludeEnd("ide");
  1851. messageSends: []
  1852. }),
  1853. $globals.HLRenameCommand.klass);
  1854. $core.addMethod(
  1855. $core.method({
  1856. selector: "label",
  1857. protocol: 'accessing',
  1858. fn: function (){
  1859. var self=this;
  1860. return "Rename";
  1861. },
  1862. //>>excludeStart("ide", pragmas.excludeIdeData);
  1863. args: [],
  1864. source: "label\x0a\x09^ 'Rename'",
  1865. referencedClasses: [],
  1866. //>>excludeEnd("ide");
  1867. messageSends: []
  1868. }),
  1869. $globals.HLRenameCommand.klass);
  1870. $core.addClass('HLRenameClassCommand', $globals.HLRenameCommand, [], 'Helios-Commands-Tools');
  1871. $core.addMethod(
  1872. $core.method({
  1873. selector: "category",
  1874. protocol: 'accessing',
  1875. fn: function (){
  1876. var self=this;
  1877. return "Classes";
  1878. },
  1879. //>>excludeStart("ide", pragmas.excludeIdeData);
  1880. args: [],
  1881. source: "category\x0a\x09^ 'Classes'",
  1882. referencedClasses: [],
  1883. //>>excludeEnd("ide");
  1884. messageSends: []
  1885. }),
  1886. $globals.HLRenameClassCommand);
  1887. $core.addMethod(
  1888. $core.method({
  1889. selector: "defaultInput",
  1890. protocol: 'defaults',
  1891. fn: function (){
  1892. var self=this;
  1893. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1894. return $core.withContext(function($ctx1) {
  1895. //>>excludeEnd("ctx");
  1896. return $recv($recv($recv(self._model())._selectedClass())._theNonMetaClass())._name();
  1897. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1898. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLRenameClassCommand)});
  1899. //>>excludeEnd("ctx");
  1900. },
  1901. //>>excludeStart("ide", pragmas.excludeIdeData);
  1902. args: [],
  1903. source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
  1904. referencedClasses: [],
  1905. //>>excludeEnd("ide");
  1906. messageSends: ["name", "theNonMetaClass", "selectedClass", "model"]
  1907. }),
  1908. $globals.HLRenameClassCommand);
  1909. $core.addMethod(
  1910. $core.method({
  1911. selector: "displayLabel",
  1912. protocol: 'accessing',
  1913. fn: function (){
  1914. var self=this;
  1915. return "Rename class to:";
  1916. },
  1917. //>>excludeStart("ide", pragmas.excludeIdeData);
  1918. args: [],
  1919. source: "displayLabel\x0a\x09^ 'Rename class to:'",
  1920. referencedClasses: [],
  1921. //>>excludeEnd("ide");
  1922. messageSends: []
  1923. }),
  1924. $globals.HLRenameClassCommand);
  1925. $core.addMethod(
  1926. $core.method({
  1927. selector: "execute",
  1928. protocol: 'executing',
  1929. fn: function (){
  1930. var self=this;
  1931. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1932. return $core.withContext(function($ctx1) {
  1933. //>>excludeEnd("ctx");
  1934. $recv(self._model())._renameClassTo_(self._input());
  1935. return self;
  1936. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1937. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRenameClassCommand)});
  1938. //>>excludeEnd("ctx");
  1939. },
  1940. //>>excludeStart("ide", pragmas.excludeIdeData);
  1941. args: [],
  1942. source: "execute\x0a\x09self model renameClassTo: self input",
  1943. referencedClasses: [],
  1944. //>>excludeEnd("ide");
  1945. messageSends: ["renameClassTo:", "model", "input"]
  1946. }),
  1947. $globals.HLRenameClassCommand);
  1948. $core.addMethod(
  1949. $core.method({
  1950. selector: "isActive",
  1951. protocol: 'testing',
  1952. fn: function (){
  1953. var self=this;
  1954. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1955. return $core.withContext(function($ctx1) {
  1956. //>>excludeEnd("ctx");
  1957. return $recv($recv(self._model())._selectedClass())._notNil();
  1958. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  1959. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRenameClassCommand)});
  1960. //>>excludeEnd("ctx");
  1961. },
  1962. //>>excludeStart("ide", pragmas.excludeIdeData);
  1963. args: [],
  1964. source: "isActive\x0a\x09^ self model selectedClass notNil",
  1965. referencedClasses: [],
  1966. //>>excludeEnd("ide");
  1967. messageSends: ["notNil", "selectedClass", "model"]
  1968. }),
  1969. $globals.HLRenameClassCommand);
  1970. $core.addMethod(
  1971. $core.method({
  1972. selector: "isInputRequired",
  1973. protocol: 'testing',
  1974. fn: function (){
  1975. var self=this;
  1976. return true;
  1977. },
  1978. //>>excludeStart("ide", pragmas.excludeIdeData);
  1979. args: [],
  1980. source: "isInputRequired\x0a\x09^ true",
  1981. referencedClasses: [],
  1982. //>>excludeEnd("ide");
  1983. messageSends: []
  1984. }),
  1985. $globals.HLRenameClassCommand);
  1986. $core.addMethod(
  1987. $core.method({
  1988. selector: "key",
  1989. protocol: 'accessing',
  1990. fn: function (){
  1991. var self=this;
  1992. return "c";
  1993. },
  1994. //>>excludeStart("ide", pragmas.excludeIdeData);
  1995. args: [],
  1996. source: "key\x0a\x09^ 'c'",
  1997. referencedClasses: [],
  1998. //>>excludeEnd("ide");
  1999. messageSends: []
  2000. }),
  2001. $globals.HLRenameClassCommand.klass);
  2002. $core.addMethod(
  2003. $core.method({
  2004. selector: "label",
  2005. protocol: 'accessing',
  2006. fn: function (){
  2007. var self=this;
  2008. return "Rename class";
  2009. },
  2010. //>>excludeStart("ide", pragmas.excludeIdeData);
  2011. args: [],
  2012. source: "label\x0a\x09^ 'Rename class'",
  2013. referencedClasses: [],
  2014. //>>excludeEnd("ide");
  2015. messageSends: []
  2016. }),
  2017. $globals.HLRenameClassCommand.klass);
  2018. $core.addMethod(
  2019. $core.method({
  2020. selector: "menuLabel",
  2021. protocol: 'accessing',
  2022. fn: function (){
  2023. var self=this;
  2024. return "Rename class...";
  2025. },
  2026. //>>excludeStart("ide", pragmas.excludeIdeData);
  2027. args: [],
  2028. source: "menuLabel\x0a\x09^ 'Rename class...'",
  2029. referencedClasses: [],
  2030. //>>excludeEnd("ide");
  2031. messageSends: []
  2032. }),
  2033. $globals.HLRenameClassCommand.klass);
  2034. $core.addClass('HLRenamePackageCommand', $globals.HLRenameCommand, [], 'Helios-Commands-Tools');
  2035. $core.addMethod(
  2036. $core.method({
  2037. selector: "category",
  2038. protocol: 'accessing',
  2039. fn: function (){
  2040. var self=this;
  2041. return "Packages";
  2042. },
  2043. //>>excludeStart("ide", pragmas.excludeIdeData);
  2044. args: [],
  2045. source: "category\x0a\x09^ 'Packages'",
  2046. referencedClasses: [],
  2047. //>>excludeEnd("ide");
  2048. messageSends: []
  2049. }),
  2050. $globals.HLRenamePackageCommand);
  2051. $core.addMethod(
  2052. $core.method({
  2053. selector: "defaultInput",
  2054. protocol: 'defaults',
  2055. fn: function (){
  2056. var self=this;
  2057. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2058. return $core.withContext(function($ctx1) {
  2059. //>>excludeEnd("ctx");
  2060. return $recv($recv(self._model())._selectedPackage())._name();
  2061. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2062. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLRenamePackageCommand)});
  2063. //>>excludeEnd("ctx");
  2064. },
  2065. //>>excludeStart("ide", pragmas.excludeIdeData);
  2066. args: [],
  2067. source: "defaultInput\x0a\x09^ self model selectedPackage name",
  2068. referencedClasses: [],
  2069. //>>excludeEnd("ide");
  2070. messageSends: ["name", "selectedPackage", "model"]
  2071. }),
  2072. $globals.HLRenamePackageCommand);
  2073. $core.addMethod(
  2074. $core.method({
  2075. selector: "displayLabel",
  2076. protocol: 'accessing',
  2077. fn: function (){
  2078. var self=this;
  2079. return "Rename package to:";
  2080. },
  2081. //>>excludeStart("ide", pragmas.excludeIdeData);
  2082. args: [],
  2083. source: "displayLabel\x0a\x09^ 'Rename package to:'",
  2084. referencedClasses: [],
  2085. //>>excludeEnd("ide");
  2086. messageSends: []
  2087. }),
  2088. $globals.HLRenamePackageCommand);
  2089. $core.addMethod(
  2090. $core.method({
  2091. selector: "execute",
  2092. protocol: 'executing',
  2093. fn: function (){
  2094. var self=this;
  2095. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2096. return $core.withContext(function($ctx1) {
  2097. //>>excludeEnd("ctx");
  2098. $recv(self._model())._renamePackageTo_(self._input());
  2099. return self;
  2100. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2101. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRenamePackageCommand)});
  2102. //>>excludeEnd("ctx");
  2103. },
  2104. //>>excludeStart("ide", pragmas.excludeIdeData);
  2105. args: [],
  2106. source: "execute\x0a\x09self model renamePackageTo: self input",
  2107. referencedClasses: [],
  2108. //>>excludeEnd("ide");
  2109. messageSends: ["renamePackageTo:", "model", "input"]
  2110. }),
  2111. $globals.HLRenamePackageCommand);
  2112. $core.addMethod(
  2113. $core.method({
  2114. selector: "isActive",
  2115. protocol: 'testing',
  2116. fn: function (){
  2117. var self=this;
  2118. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2119. return $core.withContext(function($ctx1) {
  2120. //>>excludeEnd("ctx");
  2121. return $recv($recv(self._model())._selectedPackage())._notNil();
  2122. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2123. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRenamePackageCommand)});
  2124. //>>excludeEnd("ctx");
  2125. },
  2126. //>>excludeStart("ide", pragmas.excludeIdeData);
  2127. args: [],
  2128. source: "isActive\x0a\x09^ self model selectedPackage notNil",
  2129. referencedClasses: [],
  2130. //>>excludeEnd("ide");
  2131. messageSends: ["notNil", "selectedPackage", "model"]
  2132. }),
  2133. $globals.HLRenamePackageCommand);
  2134. $core.addMethod(
  2135. $core.method({
  2136. selector: "isInputRequired",
  2137. protocol: 'testing',
  2138. fn: function (){
  2139. var self=this;
  2140. return true;
  2141. },
  2142. //>>excludeStart("ide", pragmas.excludeIdeData);
  2143. args: [],
  2144. source: "isInputRequired\x0a\x09^ true",
  2145. referencedClasses: [],
  2146. //>>excludeEnd("ide");
  2147. messageSends: []
  2148. }),
  2149. $globals.HLRenamePackageCommand);
  2150. $core.addMethod(
  2151. $core.method({
  2152. selector: "key",
  2153. protocol: 'accessing',
  2154. fn: function (){
  2155. var self=this;
  2156. return "p";
  2157. },
  2158. //>>excludeStart("ide", pragmas.excludeIdeData);
  2159. args: [],
  2160. source: "key\x0a\x09^ 'p'",
  2161. referencedClasses: [],
  2162. //>>excludeEnd("ide");
  2163. messageSends: []
  2164. }),
  2165. $globals.HLRenamePackageCommand.klass);
  2166. $core.addMethod(
  2167. $core.method({
  2168. selector: "label",
  2169. protocol: 'accessing',
  2170. fn: function (){
  2171. var self=this;
  2172. return "Rename package";
  2173. },
  2174. //>>excludeStart("ide", pragmas.excludeIdeData);
  2175. args: [],
  2176. source: "label\x0a\x09^ 'Rename package'",
  2177. referencedClasses: [],
  2178. //>>excludeEnd("ide");
  2179. messageSends: []
  2180. }),
  2181. $globals.HLRenamePackageCommand.klass);
  2182. $core.addMethod(
  2183. $core.method({
  2184. selector: "menuLabel",
  2185. protocol: 'accessing',
  2186. fn: function (){
  2187. var self=this;
  2188. return "Rename package...";
  2189. },
  2190. //>>excludeStart("ide", pragmas.excludeIdeData);
  2191. args: [],
  2192. source: "menuLabel\x0a\x09^ 'Rename package...'",
  2193. referencedClasses: [],
  2194. //>>excludeEnd("ide");
  2195. messageSends: []
  2196. }),
  2197. $globals.HLRenamePackageCommand.klass);
  2198. $core.addClass('HLRenameProtocolCommand', $globals.HLRenameCommand, [], 'Helios-Commands-Tools');
  2199. $core.addMethod(
  2200. $core.method({
  2201. selector: "category",
  2202. protocol: 'accessing',
  2203. fn: function (){
  2204. var self=this;
  2205. return "Protocols";
  2206. },
  2207. //>>excludeStart("ide", pragmas.excludeIdeData);
  2208. args: [],
  2209. source: "category\x0a\x09^ 'Protocols'",
  2210. referencedClasses: [],
  2211. //>>excludeEnd("ide");
  2212. messageSends: []
  2213. }),
  2214. $globals.HLRenameProtocolCommand);
  2215. $core.addMethod(
  2216. $core.method({
  2217. selector: "defaultInput",
  2218. protocol: 'defaults',
  2219. fn: function (){
  2220. var self=this;
  2221. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2222. return $core.withContext(function($ctx1) {
  2223. //>>excludeEnd("ctx");
  2224. return $recv(self._model())._selectedProtocol();
  2225. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2226. }, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLRenameProtocolCommand)});
  2227. //>>excludeEnd("ctx");
  2228. },
  2229. //>>excludeStart("ide", pragmas.excludeIdeData);
  2230. args: [],
  2231. source: "defaultInput\x0a\x09^ self model selectedProtocol",
  2232. referencedClasses: [],
  2233. //>>excludeEnd("ide");
  2234. messageSends: ["selectedProtocol", "model"]
  2235. }),
  2236. $globals.HLRenameProtocolCommand);
  2237. $core.addMethod(
  2238. $core.method({
  2239. selector: "displayLabel",
  2240. protocol: 'accessing',
  2241. fn: function (){
  2242. var self=this;
  2243. return "Rename protocol to:";
  2244. },
  2245. //>>excludeStart("ide", pragmas.excludeIdeData);
  2246. args: [],
  2247. source: "displayLabel\x0a\x09^ 'Rename protocol to:'",
  2248. referencedClasses: [],
  2249. //>>excludeEnd("ide");
  2250. messageSends: []
  2251. }),
  2252. $globals.HLRenameProtocolCommand);
  2253. $core.addMethod(
  2254. $core.method({
  2255. selector: "execute",
  2256. protocol: 'executing',
  2257. fn: function (){
  2258. var self=this;
  2259. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2260. return $core.withContext(function($ctx1) {
  2261. //>>excludeEnd("ctx");
  2262. $recv(self._model())._renameProtocolTo_(self._input());
  2263. return self;
  2264. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2265. }, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRenameProtocolCommand)});
  2266. //>>excludeEnd("ctx");
  2267. },
  2268. //>>excludeStart("ide", pragmas.excludeIdeData);
  2269. args: [],
  2270. source: "execute\x0a\x09self model renameProtocolTo: self input",
  2271. referencedClasses: [],
  2272. //>>excludeEnd("ide");
  2273. messageSends: ["renameProtocolTo:", "model", "input"]
  2274. }),
  2275. $globals.HLRenameProtocolCommand);
  2276. $core.addMethod(
  2277. $core.method({
  2278. selector: "isActive",
  2279. protocol: 'testing',
  2280. fn: function (){
  2281. var self=this;
  2282. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2283. return $core.withContext(function($ctx1) {
  2284. //>>excludeEnd("ctx");
  2285. return $recv($recv(self._model())._selectedProtocol())._notNil();
  2286. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  2287. }, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRenameProtocolCommand)});
  2288. //>>excludeEnd("ctx");
  2289. },
  2290. //>>excludeStart("ide", pragmas.excludeIdeData);
  2291. args: [],
  2292. source: "isActive\x0a\x09^ self model selectedProtocol notNil",
  2293. referencedClasses: [],
  2294. //>>excludeEnd("ide");
  2295. messageSends: ["notNil", "selectedProtocol", "model"]
  2296. }),
  2297. $globals.HLRenameProtocolCommand);
  2298. $core.addMethod(
  2299. $core.method({
  2300. selector: "isInputRequired",
  2301. protocol: 'testing',
  2302. fn: function (){
  2303. var self=this;
  2304. return true;
  2305. },
  2306. //>>excludeStart("ide", pragmas.excludeIdeData);
  2307. args: [],
  2308. source: "isInputRequired\x0a\x09^ true",
  2309. referencedClasses: [],
  2310. //>>excludeEnd("ide");
  2311. messageSends: []
  2312. }),
  2313. $globals.HLRenameProtocolCommand);
  2314. $core.addMethod(
  2315. $core.method({
  2316. selector: "key",
  2317. protocol: 'accessing',
  2318. fn: function (){
  2319. var self=this;
  2320. return "t";
  2321. },
  2322. //>>excludeStart("ide", pragmas.excludeIdeData);
  2323. args: [],
  2324. source: "key\x0a\x09^ 't'",
  2325. referencedClasses: [],
  2326. //>>excludeEnd("ide");
  2327. messageSends: []
  2328. }),
  2329. $globals.HLRenameProtocolCommand.klass);
  2330. $core.addMethod(
  2331. $core.method({
  2332. selector: "label",
  2333. protocol: 'accessing',
  2334. fn: function (){
  2335. var self=this;
  2336. return "Rename protocol";
  2337. },
  2338. //>>excludeStart("ide", pragmas.excludeIdeData);
  2339. args: [],
  2340. source: "label\x0a\x09^ 'Rename protocol'",
  2341. referencedClasses: [],
  2342. //>>excludeEnd("ide");
  2343. messageSends: []
  2344. }),
  2345. $globals.HLRenameProtocolCommand.klass);
  2346. $core.addMethod(
  2347. $core.method({
  2348. selector: "menuLabel",
  2349. protocol: 'accessing',
  2350. fn: function (){
  2351. var self=this;
  2352. return "Rename protocol...";
  2353. },
  2354. //>>excludeStart("ide", pragmas.excludeIdeData);
  2355. args: [],
  2356. source: "menuLabel\x0a\x09^ 'Rename protocol...'",
  2357. referencedClasses: [],
  2358. //>>excludeEnd("ide");
  2359. messageSends: []
  2360. }),
  2361. $globals.HLRenameProtocolCommand.klass);
  2362. });