1
0

Helios-Commands.js 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282
  1. smalltalk.addPackage('Helios-Commands');
  2. smalltalk.addClass('HLCommand', smalltalk.Object, [], 'Helios-Commands');
  3. smalltalk.addMethod(
  4. "_asActionBinding",
  5. smalltalk.method({
  6. selector: "asActionBinding",
  7. category: 'converting',
  8. fn: function (){
  9. var self=this;
  10. return smalltalk.withContext(function($ctx1) { var $1;
  11. $1=_st(_st((smalltalk.HLBindingAction || HLBindingAction))._on_labelled_(_st(self)._key(),_st(self)._label()))._callback_((function(){
  12. return smalltalk.withContext(function($ctx2) { return _st(self)._execute();
  13. }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
  14. return $1;
  15. }, function($ctx1) {$ctx1.fill(self,"asActionBinding",{},smalltalk.HLCommand)})},
  16. args: [],
  17. source: "asActionBinding\x0a\x09^ (HLBindingAction on: self key labelled: self label)\x0a \x09callback: [ self execute ]",
  18. messageSends: ["callback:", "execute", "on:labelled:", "key", "label"],
  19. referencedClasses: ["HLBindingAction"]
  20. }),
  21. smalltalk.HLCommand);
  22. smalltalk.addMethod(
  23. "_asBinding",
  24. smalltalk.method({
  25. selector: "asBinding",
  26. category: 'converting',
  27. fn: function (){
  28. var self=this;
  29. return smalltalk.withContext(function($ctx1) { var $2,$1;
  30. $2=_st(self)._isBindingGroup();
  31. if(smalltalk.assert($2)){
  32. $1=_st(self)._asGroupBinding();
  33. } else {
  34. $1=_st(self)._asActionBinding();
  35. };
  36. return $1;
  37. }, function($ctx1) {$ctx1.fill(self,"asBinding",{},smalltalk.HLCommand)})},
  38. args: [],
  39. source: "asBinding\x0a\x09^ self isBindingGroup\x0a\x09\x09ifTrue: [ self asGroupBinding ]\x0a\x09\x09ifFalse: [ self asActionBinding ]",
  40. messageSends: ["ifTrue:ifFalse:", "asGroupBinding", "asActionBinding", "isBindingGroup"],
  41. referencedClasses: []
  42. }),
  43. smalltalk.HLCommand);
  44. smalltalk.addMethod(
  45. "_asGroupBinding",
  46. smalltalk.method({
  47. selector: "asGroupBinding",
  48. category: 'converting',
  49. fn: function (){
  50. var self=this;
  51. return smalltalk.withContext(function($ctx1) { var $1;
  52. $1=_st((smalltalk.HLBindingGroup || HLBindingGroup))._on_labelled_(_st(self)._key(),_st(self)._label());
  53. return $1;
  54. }, function($ctx1) {$ctx1.fill(self,"asGroupBinding",{},smalltalk.HLCommand)})},
  55. args: [],
  56. source: "asGroupBinding\x0a\x09^ HLBindingGroup \x0a\x09\x09on: self key \x0a\x09\x09labelled: self label",
  57. messageSends: ["on:labelled:", "key", "label"],
  58. referencedClasses: ["HLBindingGroup"]
  59. }),
  60. smalltalk.HLCommand);
  61. smalltalk.addMethod(
  62. "_documentation",
  63. smalltalk.method({
  64. selector: "documentation",
  65. category: 'accessing',
  66. fn: function (){
  67. var self=this;
  68. return smalltalk.withContext(function($ctx1) { var $1;
  69. $1=_st(_st(self)._class())._documentation();
  70. return $1;
  71. }, function($ctx1) {$ctx1.fill(self,"documentation",{}, smalltalk.HLCommand)})},
  72. args: [],
  73. source: "documentation\x0a\x09^ self class documentation",
  74. messageSends: ["documentation", "class"],
  75. referencedClasses: []
  76. }),
  77. smalltalk.HLCommand);
  78. smalltalk.addMethod(
  79. "_execute",
  80. smalltalk.method({
  81. selector: "execute",
  82. category: 'executing',
  83. fn: function (){
  84. var self=this;
  85. return smalltalk.withContext(function($ctx1) { return self}, function($ctx1) {$ctx1.fill(self,"execute",{}, smalltalk.HLCommand)})},
  86. args: [],
  87. source: "execute\x0a\x09",
  88. messageSends: [],
  89. referencedClasses: []
  90. }),
  91. smalltalk.HLCommand);
  92. smalltalk.addMethod(
  93. "_isBindingGroup",
  94. smalltalk.method({
  95. selector: "isBindingGroup",
  96. category: 'testing',
  97. fn: function (){
  98. var self=this;
  99. return smalltalk.withContext(function($ctx1) { var $1;
  100. $1=_st(_st(_st(_st(self)._class())._methodDictionary())._includesKey_("execute"))._not();
  101. return $1;
  102. }, function($ctx1) {$ctx1.fill(self,"isBindingGroup",{},smalltalk.HLCommand)})},
  103. args: [],
  104. source: "isBindingGroup\x0a\x09^ (self class methodDictionary includesKey: 'execute') not",
  105. messageSends: ["not", "includesKey:", "methodDictionary", "class"],
  106. referencedClasses: []
  107. }),
  108. smalltalk.HLCommand);
  109. smalltalk.addMethod(
  110. "_key",
  111. smalltalk.method({
  112. selector: "key",
  113. category: 'accessing',
  114. fn: function (){
  115. var self=this;
  116. return smalltalk.withContext(function($ctx1) { var $1;
  117. $1=_st(_st(self)._class())._key();
  118. return $1;
  119. }, function($ctx1) {$ctx1.fill(self,"key",{}, smalltalk.HLCommand)})},
  120. args: [],
  121. source: "key\x0a\x09^ self class key",
  122. messageSends: ["key", "class"],
  123. referencedClasses: []
  124. }),
  125. smalltalk.HLCommand);
  126. smalltalk.addMethod(
  127. "_label",
  128. smalltalk.method({
  129. selector: "label",
  130. category: 'accessing',
  131. fn: function (){
  132. var self=this;
  133. return smalltalk.withContext(function($ctx1) { var $1;
  134. $1=_st(_st(self)._class())._label();
  135. return $1;
  136. }, function($ctx1) {$ctx1.fill(self,"label",{}, smalltalk.HLCommand)})},
  137. args: [],
  138. source: "label\x0a\x09^ self class label",
  139. messageSends: ["label", "class"],
  140. referencedClasses: []
  141. }),
  142. smalltalk.HLCommand);
  143. smalltalk.addMethod(
  144. "_registerOn_",
  145. smalltalk.method({
  146. selector: "registerOn:",
  147. category: 'registration',
  148. fn: function (aBinding){
  149. var self=this;
  150. return smalltalk.withContext(function($ctx1) { var $1;
  151. $1=_st(aBinding)._add_(_st(self)._asBinding());
  152. return $1;
  153. }, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},smalltalk.HLCommand)})},
  154. args: ["aBinding"],
  155. source: "registerOn: aBinding\x0a\x09^ aBinding add: self asBinding",
  156. messageSends: ["add:", "asBinding"],
  157. referencedClasses: []
  158. }),
  159. smalltalk.HLCommand);
  160. smalltalk.addMethod(
  161. "_concreteSubclasses",
  162. smalltalk.method({
  163. selector: "concreteSubclasses",
  164. category: 'accessing',
  165. fn: function (){
  166. var self=this;
  167. return smalltalk.withContext(function($ctx1) { var $1;
  168. $1=_st(_st(self)._subclasses())._select_((function(each){
  169. return smalltalk.withContext(function($ctx2) { return _st(each)._isConcrete();
  170. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
  171. return $1;
  172. }, function($ctx1) {$ctx1.fill(self,"concreteSubclasses",{},smalltalk.HLCommand.klass)})},
  173. args: [],
  174. source: "concreteSubclasses\x0a\x09^ self subclasses select: [ :each |\x0a\x09\x09each isConcrete ]",
  175. messageSends: ["select:", "isConcrete", "subclasses"],
  176. referencedClasses: []
  177. }),
  178. smalltalk.HLCommand.klass);
  179. smalltalk.addMethod(
  180. "_documentation",
  181. smalltalk.method({
  182. selector: "documentation",
  183. category: 'accessing',
  184. fn: function (){
  185. var self=this;
  186. return smalltalk.withContext(function($ctx1) { return "";
  187. }, function($ctx1) {$ctx1.fill(self,"documentation",{}, smalltalk.HLCommand.klass)})},
  188. args: [],
  189. source: "documentation\x0a\x09^ ''",
  190. messageSends: [],
  191. referencedClasses: []
  192. }),
  193. smalltalk.HLCommand.klass);
  194. smalltalk.addMethod(
  195. "_isConcrete",
  196. smalltalk.method({
  197. selector: "isConcrete",
  198. category: 'testing',
  199. fn: function (){
  200. var self=this;
  201. return smalltalk.withContext(function($ctx1) { var $1;
  202. $1=_st(_st(self)._key())._notNil();
  203. return $1;
  204. }, function($ctx1) {$ctx1.fill(self,"isConcrete",{},smalltalk.HLCommand.klass)})},
  205. args: [],
  206. source: "isConcrete\x0a\x09^ self key notNil",
  207. messageSends: ["notNil", "key"],
  208. referencedClasses: []
  209. }),
  210. smalltalk.HLCommand.klass);
  211. smalltalk.addMethod(
  212. "_key",
  213. smalltalk.method({
  214. selector: "key",
  215. category: 'accessing',
  216. fn: function (){
  217. var self=this;
  218. return smalltalk.withContext(function($ctx1) { return nil;
  219. }, function($ctx1) {$ctx1.fill(self,"key",{}, smalltalk.HLCommand.klass)})},
  220. args: [],
  221. source: "key\x0a\x09^ nil",
  222. messageSends: [],
  223. referencedClasses: []
  224. }),
  225. smalltalk.HLCommand.klass);
  226. smalltalk.addMethod(
  227. "_label",
  228. smalltalk.method({
  229. selector: "label",
  230. category: 'accessing',
  231. fn: function (){
  232. var self=this;
  233. return smalltalk.withContext(function($ctx1) { return "";
  234. }, function($ctx1) {$ctx1.fill(self,"label",{}, smalltalk.HLCommand.klass)})},
  235. args: [],
  236. source: "label\x0a\x09^ ''",
  237. messageSends: [],
  238. referencedClasses: []
  239. }),
  240. smalltalk.HLCommand.klass);
  241. smalltalk.addMethod(
  242. "_registerConcreteClassesOn_",
  243. smalltalk.method({
  244. selector: "registerConcreteClassesOn:",
  245. category: 'registration',
  246. fn: function (aBinding){
  247. var self=this;
  248. return smalltalk.withContext(function($ctx1) { var $1;
  249. _st(_st(self)._concreteSubclasses())._do_((function(each){
  250. var binding;
  251. return smalltalk.withContext(function($ctx2) { binding=_st(each)._registerOn_(aBinding);
  252. binding;
  253. $1=_st(binding)._isBindingGroup();
  254. if(smalltalk.assert($1)){
  255. return _st(each)._registerConcreteClassesOn_(binding);
  256. };
  257. }, function($ctx2) {$ctx2.fillBlock({each:each,binding:binding},$ctx1)})}));
  258. return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:",{aBinding:aBinding},smalltalk.HLCommand.klass)})},
  259. args: ["aBinding"],
  260. source: "registerConcreteClassesOn: aBinding\x0a\x09self concreteSubclasses do: [ :each | | binding |\x0a\x09\x09binding := each registerOn: aBinding.\x0a\x09\x09binding isBindingGroup ifTrue: [\x0a\x09\x09\x09each registerConcreteClassesOn: binding ] ]",
  261. messageSends: ["do:", "registerOn:", "ifTrue:", "registerConcreteClassesOn:", "isBindingGroup", "concreteSubclasses"],
  262. referencedClasses: []
  263. }),
  264. smalltalk.HLCommand.klass);
  265. smalltalk.addMethod(
  266. "_registerOn_",
  267. smalltalk.method({
  268. selector: "registerOn:",
  269. category: 'registration',
  270. fn: function (aBinding){
  271. var self=this;
  272. return smalltalk.withContext(function($ctx1) { var $1;
  273. $1=_st(_st(self)._new())._registerOn_(aBinding);
  274. return $1;
  275. }, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},smalltalk.HLCommand.klass)})},
  276. args: ["aBinding"],
  277. source: "registerOn: aBinding\x0a\x09^ self new registerOn: aBinding",
  278. messageSends: ["registerOn:", "new"],
  279. referencedClasses: []
  280. }),
  281. smalltalk.HLCommand.klass);
  282. smalltalk.addClass('HLCloseTabCommand', smalltalk.HLCommand, [], 'Helios-Commands');
  283. smalltalk.addMethod(
  284. "_execute",
  285. smalltalk.method({
  286. selector: "execute",
  287. category: 'executing',
  288. fn: function (){
  289. var self=this;
  290. return smalltalk.withContext(function($ctx1) { _st(_st((smalltalk.HLManager || HLManager))._current())._removeActiveTab();
  291. return self}, function($ctx1) {$ctx1.fill(self,"execute",{}, smalltalk.HLCloseTabCommand)})},
  292. args: [],
  293. source: "execute\x0a\x09HLManager current removeActiveTab",
  294. messageSends: ["removeActiveTab", "current"],
  295. referencedClasses: ["HLManager"]
  296. }),
  297. smalltalk.HLCloseTabCommand);
  298. smalltalk.addMethod(
  299. "_key",
  300. smalltalk.method({
  301. selector: "key",
  302. category: 'accessing',
  303. fn: function (){
  304. var self=this;
  305. return smalltalk.withContext(function($ctx1) { return (87);
  306. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLCloseTabCommand.klass)})},
  307. args: [],
  308. source: "key\x0a\x09^ 87",
  309. messageSends: [],
  310. referencedClasses: []
  311. }),
  312. smalltalk.HLCloseTabCommand.klass);
  313. smalltalk.addMethod(
  314. "_label",
  315. smalltalk.method({
  316. selector: "label",
  317. category: 'accessing',
  318. fn: function (){
  319. var self=this;
  320. return smalltalk.withContext(function($ctx1) { return "Close tab";
  321. }, function($ctx1) {$ctx1.fill(self,"label",{}, smalltalk.HLCloseTabCommand.klass)})},
  322. args: [],
  323. source: "label\x0a\x09^ 'Close tab'",
  324. messageSends: [],
  325. referencedClasses: []
  326. }),
  327. smalltalk.HLCloseTabCommand.klass);
  328. smalltalk.addClass('HLModelCommand', smalltalk.HLCommand, ['model'], 'Helios-Commands');
  329. smalltalk.addMethod(
  330. "_model",
  331. smalltalk.method({
  332. selector: "model",
  333. category: 'accessing',
  334. fn: function (){
  335. var self=this;
  336. return smalltalk.withContext(function($ctx1) { var $1;
  337. $1=self["@model"];
  338. return $1;
  339. }, function($ctx1) {$ctx1.fill(self,"model",{},smalltalk.HLModelCommand)})},
  340. args: [],
  341. source: "model\x0a\x09^ model",
  342. messageSends: [],
  343. referencedClasses: []
  344. }),
  345. smalltalk.HLModelCommand);
  346. smalltalk.addMethod(
  347. "_model_",
  348. smalltalk.method({
  349. selector: "model:",
  350. category: 'accessing',
  351. fn: function (aModel){
  352. var self=this;
  353. return smalltalk.withContext(function($ctx1) { self["@model"]=aModel;
  354. return self}, function($ctx1) {$ctx1.fill(self,"model:",{aModel:aModel},smalltalk.HLModelCommand)})},
  355. args: ["aModel"],
  356. source: "model: aModel\x0a\x09model := aModel",
  357. messageSends: [],
  358. referencedClasses: []
  359. }),
  360. smalltalk.HLModelCommand);
  361. smalltalk.addMethod(
  362. "_for_",
  363. smalltalk.method({
  364. selector: "for:",
  365. category: 'instance creation',
  366. fn: function (aModel){
  367. var self=this;
  368. return smalltalk.withContext(function($ctx1) { var $1;
  369. $1=_st(self)._new();
  370. return $1;
  371. }, function($ctx1) {$ctx1.fill(self,"for:",{aModel:aModel},smalltalk.HLModelCommand.klass)})},
  372. args: ["aModel"],
  373. source: "for: aModel\x0a\x09^ self new",
  374. messageSends: ["new"],
  375. referencedClasses: []
  376. }),
  377. smalltalk.HLModelCommand.klass);
  378. smalltalk.addMethod(
  379. "_registerConcreteClassesOn_for_",
  380. smalltalk.method({
  381. selector: "registerConcreteClassesOn:for:",
  382. category: 'registration',
  383. fn: function (aBinding,aModel){
  384. var self=this;
  385. return smalltalk.withContext(function($ctx1) { var $1;
  386. _st(_st(self)._concreteSubclasses())._do_((function(each){
  387. var binding;
  388. return smalltalk.withContext(function($ctx2) { binding=_st(each)._registerOn_for_(aBinding,aModel);
  389. binding;
  390. $1=_st(binding)._isBindingGroup();
  391. if(smalltalk.assert($1)){
  392. return _st(each)._registerConcreteClassesOn_for_(binding,aModel);
  393. };
  394. }, function($ctx2) {$ctx2.fillBlock({each:each,binding:binding},$ctx1)})}));
  395. return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:for:",{aBinding:aBinding,aModel:aModel},smalltalk.HLModelCommand.klass)})},
  396. args: ["aBinding", "aModel"],
  397. source: "registerConcreteClassesOn: aBinding for: aModel\x0a\x09self concreteSubclasses do: [ :each | | binding |\x0a\x09\x09binding := each registerOn: aBinding for: aModel.\x0a\x09\x09binding isBindingGroup ifTrue: [\x0a\x09\x09\x09each registerConcreteClassesOn: binding for: aModel ] ]",
  398. messageSends: ["do:", "registerOn:for:", "ifTrue:", "registerConcreteClassesOn:for:", "isBindingGroup", "concreteSubclasses"],
  399. referencedClasses: []
  400. }),
  401. smalltalk.HLModelCommand.klass);
  402. smalltalk.addMethod(
  403. "_registerOn_for_",
  404. smalltalk.method({
  405. selector: "registerOn:for:",
  406. category: 'registration',
  407. fn: function (aBinding,aModel){
  408. var self=this;
  409. return smalltalk.withContext(function($ctx1) { var $1;
  410. $1=_st(_st(self)._for_(aModel))._registerOn_(aBinding);
  411. return $1;
  412. }, function($ctx1) {$ctx1.fill(self,"registerOn:for:",{aBinding:aBinding,aModel:aModel},smalltalk.HLModelCommand.klass)})},
  413. args: ["aBinding", "aModel"],
  414. source: "registerOn: aBinding for: aModel\x0a\x09^ (self for: aModel) registerOn: aBinding",
  415. messageSends: ["registerOn:", "for:"],
  416. referencedClasses: []
  417. }),
  418. smalltalk.HLModelCommand.klass);
  419. smalltalk.addClass('HLBrowserCommand', smalltalk.HLModelCommand, [], 'Helios-Commands');
  420. smalltalk.addMethod(
  421. "_for_",
  422. smalltalk.method({
  423. selector: "for:",
  424. category: 'instance creation',
  425. fn: function (aBrowserModel){
  426. var self=this;
  427. return smalltalk.withContext(function($ctx1) { var $2,$3,$1;
  428. $2=_st(self)._new();
  429. _st($2)._model_(aBrowserModel);
  430. $3=_st($2)._yourself();
  431. $1=$3;
  432. return $1;
  433. }, function($ctx1) {$ctx1.fill(self,"for:",{aBrowserModel:aBrowserModel},smalltalk.HLBrowserCommand.klass)})},
  434. args: ["aBrowserModel"],
  435. source: "for: aBrowserModel\x0a\x09^ self new\x0a \x09model: aBrowserModel;\x0a yourself",
  436. messageSends: ["model:", "new", "yourself"],
  437. referencedClasses: []
  438. }),
  439. smalltalk.HLBrowserCommand.klass);
  440. smalltalk.addClass('HLGoToCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands');
  441. smalltalk.addMethod(
  442. "_key",
  443. smalltalk.method({
  444. selector: "key",
  445. category: 'accessing',
  446. fn: function (){
  447. var self=this;
  448. return smalltalk.withContext(function($ctx1) { return (71);
  449. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToCommand.klass)})},
  450. args: [],
  451. source: "key\x0a\x09^ 71",
  452. messageSends: [],
  453. referencedClasses: []
  454. }),
  455. smalltalk.HLGoToCommand.klass);
  456. smalltalk.addMethod(
  457. "_label",
  458. smalltalk.method({
  459. selector: "label",
  460. category: 'accessing',
  461. fn: function (){
  462. var self=this;
  463. return smalltalk.withContext(function($ctx1) { return "Go to";
  464. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToCommand.klass)})},
  465. args: [],
  466. source: "label\x0a\x09^ 'Go to'",
  467. messageSends: [],
  468. referencedClasses: []
  469. }),
  470. smalltalk.HLGoToCommand.klass);
  471. smalltalk.addClass('HLGoToClassesCommand', smalltalk.HLGoToCommand, [], 'Helios-Commands');
  472. smalltalk.addMethod(
  473. "_execute",
  474. smalltalk.method({
  475. selector: "execute",
  476. category: 'executing',
  477. fn: function (){
  478. var self=this;
  479. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._focusOnClasses();
  480. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToClassesCommand)})},
  481. args: [],
  482. source: "execute\x0a\x09self model focusOnClasses",
  483. messageSends: ["focusOnClasses", "model"],
  484. referencedClasses: []
  485. }),
  486. smalltalk.HLGoToClassesCommand);
  487. smalltalk.addMethod(
  488. "_key",
  489. smalltalk.method({
  490. selector: "key",
  491. category: 'accessing',
  492. fn: function (){
  493. var self=this;
  494. return smalltalk.withContext(function($ctx1) { return (67);
  495. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToClassesCommand.klass)})},
  496. args: [],
  497. source: "key\x0a\x09\x22c\x22\x0a \x0a\x09^ 67",
  498. messageSends: [],
  499. referencedClasses: []
  500. }),
  501. smalltalk.HLGoToClassesCommand.klass);
  502. smalltalk.addMethod(
  503. "_label",
  504. smalltalk.method({
  505. selector: "label",
  506. category: 'accessing',
  507. fn: function (){
  508. var self=this;
  509. return smalltalk.withContext(function($ctx1) { return "Classes";
  510. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToClassesCommand.klass)})},
  511. args: [],
  512. source: "label\x0a\x09^ 'Classes'",
  513. messageSends: [],
  514. referencedClasses: []
  515. }),
  516. smalltalk.HLGoToClassesCommand.klass);
  517. smalltalk.addClass('HLGoToMethodsCommand', smalltalk.HLGoToCommand, [], 'Helios-Commands');
  518. smalltalk.addMethod(
  519. "_execute",
  520. smalltalk.method({
  521. selector: "execute",
  522. category: 'executing',
  523. fn: function (){
  524. var self=this;
  525. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._focusOnMethods();
  526. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToMethodsCommand)})},
  527. args: [],
  528. source: "execute\x0a\x09self model focusOnMethods",
  529. messageSends: ["focusOnMethods", "model"],
  530. referencedClasses: []
  531. }),
  532. smalltalk.HLGoToMethodsCommand);
  533. smalltalk.addMethod(
  534. "_key",
  535. smalltalk.method({
  536. selector: "key",
  537. category: 'accessing',
  538. fn: function (){
  539. var self=this;
  540. return smalltalk.withContext(function($ctx1) { return (77);
  541. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToMethodsCommand.klass)})},
  542. args: [],
  543. source: "key\x0a\x09\x22m\x22\x0a \x0a\x09^ 77",
  544. messageSends: [],
  545. referencedClasses: []
  546. }),
  547. smalltalk.HLGoToMethodsCommand.klass);
  548. smalltalk.addMethod(
  549. "_label",
  550. smalltalk.method({
  551. selector: "label",
  552. category: 'accessing',
  553. fn: function (){
  554. var self=this;
  555. return smalltalk.withContext(function($ctx1) { return "Methods";
  556. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToMethodsCommand.klass)})},
  557. args: [],
  558. source: "label\x0a\x09^ 'Methods'",
  559. messageSends: [],
  560. referencedClasses: []
  561. }),
  562. smalltalk.HLGoToMethodsCommand.klass);
  563. smalltalk.addClass('HLGoToPackagesCommand', smalltalk.HLGoToCommand, [], 'Helios-Commands');
  564. smalltalk.addMethod(
  565. "_execute",
  566. smalltalk.method({
  567. selector: "execute",
  568. category: 'executing',
  569. fn: function (){
  570. var self=this;
  571. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._focusOnPackages();
  572. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToPackagesCommand)})},
  573. args: [],
  574. source: "execute\x0a\x09self model focusOnPackages",
  575. messageSends: ["focusOnPackages", "model"],
  576. referencedClasses: []
  577. }),
  578. smalltalk.HLGoToPackagesCommand);
  579. smalltalk.addMethod(
  580. "_key",
  581. smalltalk.method({
  582. selector: "key",
  583. category: 'accessing',
  584. fn: function (){
  585. var self=this;
  586. return smalltalk.withContext(function($ctx1) { return (80);
  587. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToPackagesCommand.klass)})},
  588. args: [],
  589. source: "key\x0a\x09\x22p\x22\x0a \x0a\x09^ 80",
  590. messageSends: [],
  591. referencedClasses: []
  592. }),
  593. smalltalk.HLGoToPackagesCommand.klass);
  594. smalltalk.addMethod(
  595. "_label",
  596. smalltalk.method({
  597. selector: "label",
  598. category: 'accessing',
  599. fn: function (){
  600. var self=this;
  601. return smalltalk.withContext(function($ctx1) { return "Packages";
  602. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToPackagesCommand.klass)})},
  603. args: [],
  604. source: "label\x0a\x09^ 'Packages'",
  605. messageSends: [],
  606. referencedClasses: []
  607. }),
  608. smalltalk.HLGoToPackagesCommand.klass);
  609. smalltalk.addClass('HLGoToProtocolsCommand', smalltalk.HLGoToCommand, [], 'Helios-Commands');
  610. smalltalk.addMethod(
  611. "_execute",
  612. smalltalk.method({
  613. selector: "execute",
  614. category: 'executing',
  615. fn: function (){
  616. var self=this;
  617. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._focusOnProtocols();
  618. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToProtocolsCommand)})},
  619. args: [],
  620. source: "execute\x0a\x09self model focusOnProtocols",
  621. messageSends: ["focusOnProtocols", "model"],
  622. referencedClasses: []
  623. }),
  624. smalltalk.HLGoToProtocolsCommand);
  625. smalltalk.addMethod(
  626. "_key",
  627. smalltalk.method({
  628. selector: "key",
  629. category: 'accessing',
  630. fn: function (){
  631. var self=this;
  632. return smalltalk.withContext(function($ctx1) { return (84);
  633. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToProtocolsCommand.klass)})},
  634. args: [],
  635. source: "key\x0a\x09\x22p\x22\x0a \x0a\x09^ 84",
  636. messageSends: [],
  637. referencedClasses: []
  638. }),
  639. smalltalk.HLGoToProtocolsCommand.klass);
  640. smalltalk.addMethod(
  641. "_label",
  642. smalltalk.method({
  643. selector: "label",
  644. category: 'accessing',
  645. fn: function (){
  646. var self=this;
  647. return smalltalk.withContext(function($ctx1) { return "Protocols";
  648. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToProtocolsCommand.klass)})},
  649. args: [],
  650. source: "label\x0a\x09^ 'Protocols'",
  651. messageSends: [],
  652. referencedClasses: []
  653. }),
  654. smalltalk.HLGoToProtocolsCommand.klass);
  655. smalltalk.addClass('HLGoToSourceCodeCommand', smalltalk.HLGoToCommand, [], 'Helios-Commands');
  656. smalltalk.addMethod(
  657. "_execute",
  658. smalltalk.method({
  659. selector: "execute",
  660. category: 'executing',
  661. fn: function (){
  662. var self=this;
  663. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._focusOnSourceCode();
  664. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToSourceCodeCommand)})},
  665. args: [],
  666. source: "execute\x0a\x09self model focusOnSourceCode",
  667. messageSends: ["focusOnSourceCode", "model"],
  668. referencedClasses: []
  669. }),
  670. smalltalk.HLGoToSourceCodeCommand);
  671. smalltalk.addMethod(
  672. "_key",
  673. smalltalk.method({
  674. selector: "key",
  675. category: 'accessing',
  676. fn: function (){
  677. var self=this;
  678. return smalltalk.withContext(function($ctx1) { return (83);
  679. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToSourceCodeCommand.klass)})},
  680. args: [],
  681. source: "key\x0a\x09\x22s\x22\x0a \x0a\x09^ 83",
  682. messageSends: [],
  683. referencedClasses: []
  684. }),
  685. smalltalk.HLGoToSourceCodeCommand.klass);
  686. smalltalk.addMethod(
  687. "_label",
  688. smalltalk.method({
  689. selector: "label",
  690. category: 'accessing',
  691. fn: function (){
  692. var self=this;
  693. return smalltalk.withContext(function($ctx1) { return "Source code";
  694. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToSourceCodeCommand.klass)})},
  695. args: [],
  696. source: "label\x0a\x09^ 'Source code'",
  697. messageSends: [],
  698. referencedClasses: []
  699. }),
  700. smalltalk.HLGoToSourceCodeCommand.klass);
  701. smalltalk.addClass('HLMoveToCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands');
  702. smalltalk.addMethod(
  703. "_key",
  704. smalltalk.method({
  705. selector: "key",
  706. category: 'accessing',
  707. fn: function (){
  708. var self=this;
  709. return smalltalk.withContext(function($ctx1) { return (77);
  710. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLMoveToCommand.klass)})},
  711. args: [],
  712. source: "key\x0a\x09^ 77",
  713. messageSends: [],
  714. referencedClasses: []
  715. }),
  716. smalltalk.HLMoveToCommand.klass);
  717. smalltalk.addMethod(
  718. "_label",
  719. smalltalk.method({
  720. selector: "label",
  721. category: 'accessing',
  722. fn: function (){
  723. var self=this;
  724. return smalltalk.withContext(function($ctx1) { return "Move";
  725. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLMoveToCommand.klass)})},
  726. args: [],
  727. source: "label\x0a\x09^ 'Move'",
  728. messageSends: [],
  729. referencedClasses: []
  730. }),
  731. smalltalk.HLMoveToCommand.klass);
  732. smalltalk.addClass('HLMoveMethodToCommand', smalltalk.HLMoveToCommand, [], 'Helios-Commands');
  733. smalltalk.addMethod(
  734. "_key",
  735. smalltalk.method({
  736. selector: "key",
  737. category: 'accessing',
  738. fn: function (){
  739. var self=this;
  740. return smalltalk.withContext(function($ctx1) { return (77);
  741. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLMoveMethodToCommand.klass)})},
  742. args: [],
  743. source: "key\x0a\x09^ 77",
  744. messageSends: [],
  745. referencedClasses: []
  746. }),
  747. smalltalk.HLMoveMethodToCommand.klass);
  748. smalltalk.addMethod(
  749. "_label",
  750. smalltalk.method({
  751. selector: "label",
  752. category: 'accessing',
  753. fn: function (){
  754. var self=this;
  755. return smalltalk.withContext(function($ctx1) { return "Method";
  756. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLMoveMethodToCommand.klass)})},
  757. args: [],
  758. source: "label\x0a\x09^ 'Method'",
  759. messageSends: [],
  760. referencedClasses: []
  761. }),
  762. smalltalk.HLMoveMethodToCommand.klass);
  763. smalltalk.addClass('HLMoveMethodToClassCommand', smalltalk.HLMoveMethodToCommand, [], 'Helios-Commands');
  764. smalltalk.addMethod(
  765. "_execute",
  766. smalltalk.method({
  767. selector: "execute",
  768. category: 'executing',
  769. fn: function (){
  770. var self=this;
  771. return smalltalk.withContext(function($ctx1) { return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLMoveMethodToClassCommand)})},
  772. args: [],
  773. source: "execute",
  774. messageSends: [],
  775. referencedClasses: []
  776. }),
  777. smalltalk.HLMoveMethodToClassCommand);
  778. smalltalk.addMethod(
  779. "_key",
  780. smalltalk.method({
  781. selector: "key",
  782. category: 'accessing',
  783. fn: function (){
  784. var self=this;
  785. return smalltalk.withContext(function($ctx1) { return (67);
  786. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLMoveMethodToClassCommand.klass)})},
  787. args: [],
  788. source: "key\x0a\x09^ 67",
  789. messageSends: [],
  790. referencedClasses: []
  791. }),
  792. smalltalk.HLMoveMethodToClassCommand.klass);
  793. smalltalk.addMethod(
  794. "_label",
  795. smalltalk.method({
  796. selector: "label",
  797. category: 'accessing',
  798. fn: function (){
  799. var self=this;
  800. return smalltalk.withContext(function($ctx1) { return "to class";
  801. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLMoveMethodToClassCommand.klass)})},
  802. args: [],
  803. source: "label\x09\x0a\x09^ 'to class'",
  804. messageSends: [],
  805. referencedClasses: []
  806. }),
  807. smalltalk.HLMoveMethodToClassCommand.klass);
  808. smalltalk.addClass('HLMoveMethodToProtocolCommand', smalltalk.HLMoveMethodToCommand, [], 'Helios-Commands');
  809. smalltalk.addMethod(
  810. "_execute",
  811. smalltalk.method({
  812. selector: "execute",
  813. category: 'executing',
  814. fn: function (){
  815. var self=this;
  816. return smalltalk.withContext(function($ctx1) { return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLMoveMethodToProtocolCommand)})},
  817. args: [],
  818. source: "execute",
  819. messageSends: [],
  820. referencedClasses: []
  821. }),
  822. smalltalk.HLMoveMethodToProtocolCommand);
  823. smalltalk.addMethod(
  824. "_key",
  825. smalltalk.method({
  826. selector: "key",
  827. category: 'accessing',
  828. fn: function (){
  829. var self=this;
  830. return smalltalk.withContext(function($ctx1) { return (84);
  831. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLMoveMethodToProtocolCommand.klass)})},
  832. args: [],
  833. source: "key\x0a\x09^ 84",
  834. messageSends: [],
  835. referencedClasses: []
  836. }),
  837. smalltalk.HLMoveMethodToProtocolCommand.klass);
  838. smalltalk.addMethod(
  839. "_label",
  840. smalltalk.method({
  841. selector: "label",
  842. category: 'accessing',
  843. fn: function (){
  844. var self=this;
  845. return smalltalk.withContext(function($ctx1) { return "to protocol";
  846. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLMoveMethodToProtocolCommand.klass)})},
  847. args: [],
  848. source: "label\x0a\x09^ 'to protocol'",
  849. messageSends: [],
  850. referencedClasses: []
  851. }),
  852. smalltalk.HLMoveMethodToProtocolCommand.klass);
  853. smalltalk.addClass('HLToggleCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands');
  854. smalltalk.addMethod(
  855. "_key",
  856. smalltalk.method({
  857. selector: "key",
  858. category: 'accessing',
  859. fn: function (){
  860. var self=this;
  861. return smalltalk.withContext(function($ctx1) { return (84);
  862. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleCommand.klass)})},
  863. args: [],
  864. source: "key\x0a\x09^ 84",
  865. messageSends: [],
  866. referencedClasses: []
  867. }),
  868. smalltalk.HLToggleCommand.klass);
  869. smalltalk.addMethod(
  870. "_label",
  871. smalltalk.method({
  872. selector: "label",
  873. category: 'accessing',
  874. fn: function (){
  875. var self=this;
  876. return smalltalk.withContext(function($ctx1) { return "Toggle";
  877. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleCommand.klass)})},
  878. args: [],
  879. source: "label\x0a\x09^ 'Toggle'",
  880. messageSends: [],
  881. referencedClasses: []
  882. }),
  883. smalltalk.HLToggleCommand.klass);
  884. smalltalk.addClass('HLToggleClassSideCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands');
  885. smalltalk.addMethod(
  886. "_execute",
  887. smalltalk.method({
  888. selector: "execute",
  889. category: 'executing',
  890. fn: function (){
  891. var self=this;
  892. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._showInstance_(false);
  893. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleClassSideCommand)})},
  894. args: [],
  895. source: "execute\x0a\x09self model showInstance: false",
  896. messageSends: ["showInstance:", "model"],
  897. referencedClasses: []
  898. }),
  899. smalltalk.HLToggleClassSideCommand);
  900. smalltalk.addMethod(
  901. "_key",
  902. smalltalk.method({
  903. selector: "key",
  904. category: 'accessing',
  905. fn: function (){
  906. var self=this;
  907. return smalltalk.withContext(function($ctx1) { return (67);
  908. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleClassSideCommand.klass)})},
  909. args: [],
  910. source: "key\x0a\x09\x22c\x22\x0a \x0a\x09^ 67",
  911. messageSends: [],
  912. referencedClasses: []
  913. }),
  914. smalltalk.HLToggleClassSideCommand.klass);
  915. smalltalk.addMethod(
  916. "_label",
  917. smalltalk.method({
  918. selector: "label",
  919. category: 'accessing',
  920. fn: function (){
  921. var self=this;
  922. return smalltalk.withContext(function($ctx1) { return "Class side";
  923. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleClassSideCommand.klass)})},
  924. args: [],
  925. source: "label\x0a\x09^ 'Class side'",
  926. messageSends: [],
  927. referencedClasses: []
  928. }),
  929. smalltalk.HLToggleClassSideCommand.klass);
  930. smalltalk.addClass('HLToggleInstanceSideCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands');
  931. smalltalk.addMethod(
  932. "_execute",
  933. smalltalk.method({
  934. selector: "execute",
  935. category: 'executing',
  936. fn: function (){
  937. var self=this;
  938. return smalltalk.withContext(function($ctx1) { _st(_st(self)._model())._showInstance_(true);
  939. return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleInstanceSideCommand)})},
  940. args: [],
  941. source: "execute\x0a\x09self model showInstance: true",
  942. messageSends: ["showInstance:", "model"],
  943. referencedClasses: []
  944. }),
  945. smalltalk.HLToggleInstanceSideCommand);
  946. smalltalk.addMethod(
  947. "_key",
  948. smalltalk.method({
  949. selector: "key",
  950. category: 'accessing',
  951. fn: function (){
  952. var self=this;
  953. return smalltalk.withContext(function($ctx1) { return (73);
  954. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleInstanceSideCommand.klass)})},
  955. args: [],
  956. source: "key\x0a\x09\x22i\x22\x0a \x0a\x09^ 73",
  957. messageSends: [],
  958. referencedClasses: []
  959. }),
  960. smalltalk.HLToggleInstanceSideCommand.klass);
  961. smalltalk.addMethod(
  962. "_label",
  963. smalltalk.method({
  964. selector: "label",
  965. category: 'accessing',
  966. fn: function (){
  967. var self=this;
  968. return smalltalk.withContext(function($ctx1) { return "Instance side";
  969. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleInstanceSideCommand.klass)})},
  970. args: [],
  971. source: "label\x0a\x09^ 'Instance side'",
  972. messageSends: [],
  973. referencedClasses: []
  974. }),
  975. smalltalk.HLToggleInstanceSideCommand.klass);
  976. smalltalk.addClass('HLOpenCommand', smalltalk.HLCommand, [], 'Helios-Commands');
  977. smalltalk.addMethod(
  978. "_key",
  979. smalltalk.method({
  980. selector: "key",
  981. category: 'accessing',
  982. fn: function (){
  983. var self=this;
  984. return smalltalk.withContext(function($ctx1) { return (79);
  985. }, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLOpenCommand.klass)})},
  986. args: [],
  987. source: "key\x0a\x09^ 79",
  988. messageSends: [],
  989. referencedClasses: []
  990. }),
  991. smalltalk.HLOpenCommand.klass);
  992. smalltalk.addMethod(
  993. "_label",
  994. smalltalk.method({
  995. selector: "label",
  996. category: 'accessing',
  997. fn: function (){
  998. var self=this;
  999. return smalltalk.withContext(function($ctx1) { return "Open";
  1000. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLOpenCommand.klass)})},
  1001. args: [],
  1002. source: "label\x0a\x09^ 'Open'",
  1003. messageSends: [],
  1004. referencedClasses: []
  1005. }),
  1006. smalltalk.HLOpenCommand.klass);
  1007. smalltalk.addClass('HLOpenBrowserCommand', smalltalk.HLOpenCommand, [], 'Helios-Commands');
  1008. smalltalk.addMethod(
  1009. "_execute",
  1010. smalltalk.method({
  1011. selector: "execute",
  1012. category: 'executing',
  1013. fn: function (){
  1014. var self=this;
  1015. return smalltalk.withContext(function($ctx1) { var $1;
  1016. $1=_st((smalltalk.HLBrowser || HLBrowser))._openAsTab();
  1017. return $1;
  1018. }, function($ctx1) {$ctx1.fill(self,"execute",{}, smalltalk.HLOpenBrowserCommand)})},
  1019. args: [],
  1020. source: "execute\x0a\x09^ HLBrowser openAsTab",
  1021. messageSends: ["openAsTab"],
  1022. referencedClasses: ["HLBrowser"]
  1023. }),
  1024. smalltalk.HLOpenBrowserCommand);
  1025. smalltalk.addMethod(
  1026. "_key",
  1027. smalltalk.method({
  1028. selector: "key",
  1029. category: 'accessing',
  1030. fn: function (){
  1031. var self=this;
  1032. return smalltalk.withContext(function($ctx1) { return (66);
  1033. }, function($ctx1) {$ctx1.fill(self,"key",{}, smalltalk.HLOpenBrowserCommand.klass)})},
  1034. args: [],
  1035. source: "key\x0a\x09^ 66",
  1036. messageSends: [],
  1037. referencedClasses: []
  1038. }),
  1039. smalltalk.HLOpenBrowserCommand.klass);
  1040. smalltalk.addMethod(
  1041. "_label",
  1042. smalltalk.method({
  1043. selector: "label",
  1044. category: 'accessing',
  1045. fn: function (){
  1046. var self=this;
  1047. return smalltalk.withContext(function($ctx1) { return "Browser";
  1048. }, function($ctx1) {$ctx1.fill(self,"label",{}, smalltalk.HLOpenBrowserCommand.klass)})},
  1049. args: [],
  1050. source: "label\x0a\x09^ 'Browser'",
  1051. messageSends: [],
  1052. referencedClasses: []
  1053. }),
  1054. smalltalk.HLOpenBrowserCommand.klass);
  1055. smalltalk.addClass('HLOpenTranscriptCommand', smalltalk.HLOpenCommand, [], 'Helios-Commands');
  1056. smalltalk.addMethod(
  1057. "_execute",
  1058. smalltalk.method({
  1059. selector: "execute",
  1060. category: 'executing',
  1061. fn: function (){
  1062. var self=this;
  1063. return smalltalk.withContext(function($ctx1) { var $1;
  1064. $1=_st((smalltalk.HLTranscript || HLTranscript))._openAsTab();
  1065. return $1;
  1066. }, function($ctx1) {$ctx1.fill(self,"execute",{}, smalltalk.HLOpenTranscriptCommand)})},
  1067. args: [],
  1068. source: "execute\x0a\x09^ HLTranscript openAsTab",
  1069. messageSends: ["openAsTab"],
  1070. referencedClasses: ["HLTranscript"]
  1071. }),
  1072. smalltalk.HLOpenTranscriptCommand);
  1073. smalltalk.addMethod(
  1074. "_key",
  1075. smalltalk.method({
  1076. selector: "key",
  1077. category: 'accessing',
  1078. fn: function (){
  1079. var self=this;
  1080. return smalltalk.withContext(function($ctx1) { return (84);
  1081. }, function($ctx1) {$ctx1.fill(self,"key",{}, smalltalk.HLOpenTranscriptCommand.klass)})},
  1082. args: [],
  1083. source: "key\x0a\x09^ 84",
  1084. messageSends: [],
  1085. referencedClasses: []
  1086. }),
  1087. smalltalk.HLOpenTranscriptCommand.klass);
  1088. smalltalk.addMethod(
  1089. "_label",
  1090. smalltalk.method({
  1091. selector: "label",
  1092. category: 'accessing',
  1093. fn: function (){
  1094. var self=this;
  1095. return smalltalk.withContext(function($ctx1) { return "Transcript";
  1096. }, function($ctx1) {$ctx1.fill(self,"label",{}, smalltalk.HLOpenTranscriptCommand.klass)})},
  1097. args: [],
  1098. source: "label\x0a\x09^ 'Transcript'",
  1099. messageSends: [],
  1100. referencedClasses: []
  1101. }),
  1102. smalltalk.HLOpenTranscriptCommand.klass);
  1103. smalltalk.addClass('HLOpenWorkspaceCommand', smalltalk.HLOpenCommand, [], 'Helios-Commands');
  1104. smalltalk.addMethod(
  1105. "_execute",
  1106. smalltalk.method({
  1107. selector: "execute",
  1108. category: 'executing',
  1109. fn: function (){
  1110. var self=this;
  1111. return smalltalk.withContext(function($ctx1) { var $1;
  1112. $1=_st((smalltalk.HLCodeWidget || HLCodeWidget))._openAsTab();
  1113. return $1;
  1114. }, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLOpenWorkspaceCommand)})},
  1115. args: [],
  1116. source: "execute\x0a\x09^ HLCodeWidget openAsTab",
  1117. messageSends: ["openAsTab"],
  1118. referencedClasses: ["HLCodeWidget"]
  1119. }),
  1120. smalltalk.HLOpenWorkspaceCommand);
  1121. smalltalk.addMethod(
  1122. "_key",
  1123. smalltalk.method({
  1124. selector: "key",
  1125. category: 'accessing',
  1126. fn: function (){
  1127. var self=this;
  1128. return smalltalk.withContext(function($ctx1) { return (87);
  1129. }, function($ctx1) {$ctx1.fill(self,"key",{}, smalltalk.HLOpenWorkspaceCommand.klass)})},
  1130. args: [],
  1131. source: "key\x0a\x09^ 87",
  1132. messageSends: [],
  1133. referencedClasses: []
  1134. }),
  1135. smalltalk.HLOpenWorkspaceCommand.klass);
  1136. smalltalk.addMethod(
  1137. "_label",
  1138. smalltalk.method({
  1139. selector: "label",
  1140. category: 'accessing',
  1141. fn: function (){
  1142. var self=this;
  1143. return smalltalk.withContext(function($ctx1) { return "Workspace";
  1144. }, function($ctx1) {$ctx1.fill(self,"label",{}, smalltalk.HLOpenWorkspaceCommand.klass)})},
  1145. args: [],
  1146. source: "label\x0a\x09^ 'Workspace'",
  1147. messageSends: [],
  1148. referencedClasses: []
  1149. }),
  1150. smalltalk.HLOpenWorkspaceCommand.klass);
  1151. smalltalk.addClass('HLViewCommand', smalltalk.HLCommand, [], 'Helios-Commands');
  1152. smalltalk.addMethod(
  1153. "_label",
  1154. smalltalk.method({
  1155. selector: "label",
  1156. category: 'accessing',
  1157. fn: function (){
  1158. var self=this;
  1159. return smalltalk.withContext(function($ctx1) { return "View";
  1160. }, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLViewCommand.klass)})},
  1161. args: [],
  1162. source: "label\x0a\x09^ 'View'",
  1163. messageSends: [],
  1164. referencedClasses: []
  1165. }),
  1166. smalltalk.HLViewCommand.klass);