Kernel-Announcements.js 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146
  1. define("amber_core/Kernel-Announcements", ["amber/boot", "amber_core/Kernel-Objects"], function($boot){"use strict";
  2. var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
  3. $core.addPackage('Kernel-Announcements');
  4. $core.packages["Kernel-Announcements"].innerEval = function (expr) { return eval(expr); };
  5. $core.packages["Kernel-Announcements"].transport = {"type":"amd","amdNamespace":"amber_core"};
  6. $core.addClass('AnnouncementSubscription', $globals.Object, ['valuable', 'announcementClass'], 'Kernel-Announcements');
  7. //>>excludeStart("ide", pragmas.excludeIdeData);
  8. $globals.AnnouncementSubscription.comment="I am a single entry in a subscription registry of an `Announcer`.\x0aSeveral subscriptions by the same object is possible.";
  9. //>>excludeEnd("ide");
  10. $core.addMethod(
  11. $core.method({
  12. selector: "announcementClass",
  13. protocol: 'accessing',
  14. fn: function (){
  15. var self=this;
  16. return self["@announcementClass"];
  17. },
  18. //>>excludeStart("ide", pragmas.excludeIdeData);
  19. args: [],
  20. source: "announcementClass\x0a\x09^ announcementClass",
  21. referencedClasses: [],
  22. //>>excludeEnd("ide");
  23. messageSends: []
  24. }),
  25. $globals.AnnouncementSubscription);
  26. $core.addMethod(
  27. $core.method({
  28. selector: "announcementClass:",
  29. protocol: 'accessing',
  30. fn: function (aClass){
  31. var self=this;
  32. self["@announcementClass"]=aClass;
  33. return self;
  34. },
  35. //>>excludeStart("ide", pragmas.excludeIdeData);
  36. args: ["aClass"],
  37. source: "announcementClass: aClass\x0a\x09announcementClass := aClass",
  38. referencedClasses: [],
  39. //>>excludeEnd("ide");
  40. messageSends: []
  41. }),
  42. $globals.AnnouncementSubscription);
  43. $core.addMethod(
  44. $core.method({
  45. selector: "deliver:",
  46. protocol: 'announcing',
  47. fn: function (anAnnouncement){
  48. var self=this;
  49. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  50. return $core.withContext(function($ctx1) {
  51. //>>excludeEnd("ctx");
  52. var $1;
  53. $1=self._handlesAnnouncement_(anAnnouncement);
  54. if($core.assert($1)){
  55. $recv(self._valuable())._value_(anAnnouncement);
  56. };
  57. return self;
  58. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  59. }, function($ctx1) {$ctx1.fill(self,"deliver:",{anAnnouncement:anAnnouncement},$globals.AnnouncementSubscription)});
  60. //>>excludeEnd("ctx");
  61. },
  62. //>>excludeStart("ide", pragmas.excludeIdeData);
  63. args: ["anAnnouncement"],
  64. source: "deliver: anAnnouncement\x0a\x09(self handlesAnnouncement: anAnnouncement)\x0a\x09\x09ifTrue: [ self valuable value: anAnnouncement ]",
  65. referencedClasses: [],
  66. //>>excludeEnd("ide");
  67. messageSends: ["ifTrue:", "handlesAnnouncement:", "value:", "valuable"]
  68. }),
  69. $globals.AnnouncementSubscription);
  70. $core.addMethod(
  71. $core.method({
  72. selector: "handlesAnnouncement:",
  73. protocol: 'announcing',
  74. fn: function (anAnnouncement){
  75. var self=this;
  76. function $Smalltalk(){return $globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  77. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  78. return $core.withContext(function($ctx1) {
  79. //>>excludeEnd("ctx");
  80. var $2,$3,$1,$receiver;
  81. $2=$recv($Smalltalk())._globals();
  82. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  83. $ctx1.sendIdx["globals"]=1;
  84. //>>excludeEnd("ctx");
  85. $3=$recv(self._announcementClass())._name();
  86. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  87. $ctx1.sendIdx["name"]=1;
  88. //>>excludeEnd("ctx");
  89. $1=$recv($2)._at_($3);
  90. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  91. $ctx1.sendIdx["at:"]=1;
  92. //>>excludeEnd("ctx");
  93. if(($receiver = $1) == null || $receiver.isNil){
  94. return false;
  95. } else {
  96. var class_;
  97. class_=$receiver;
  98. return $recv($recv($recv($Smalltalk())._globals())._at_($recv($recv($recv(anAnnouncement)._class())._theNonMetaClass())._name()))._includesBehavior_(class_);
  99. };
  100. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  101. }, function($ctx1) {$ctx1.fill(self,"handlesAnnouncement:",{anAnnouncement:anAnnouncement},$globals.AnnouncementSubscription)});
  102. //>>excludeEnd("ctx");
  103. },
  104. //>>excludeStart("ide", pragmas.excludeIdeData);
  105. args: ["anAnnouncement"],
  106. source: "handlesAnnouncement: anAnnouncement\x0a\x09\x22anAnnouncement might be announced from within another Amber environment\x22\x0a\x09\x0a\x09^ (Smalltalk globals at: self announcementClass name)\x0a\x09\x09ifNil: [ ^ false ]\x0a\x09\x09ifNotNil: [ :class |\x0a\x09\x09(Smalltalk globals at: anAnnouncement class theNonMetaClass name) includesBehavior: class ]",
  107. referencedClasses: ["Smalltalk"],
  108. //>>excludeEnd("ide");
  109. messageSends: ["ifNil:ifNotNil:", "at:", "globals", "name", "announcementClass", "includesBehavior:", "theNonMetaClass", "class"]
  110. }),
  111. $globals.AnnouncementSubscription);
  112. $core.addMethod(
  113. $core.method({
  114. selector: "receiver",
  115. protocol: 'accessing',
  116. fn: function (){
  117. var self=this;
  118. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  119. return $core.withContext(function($ctx1) {
  120. //>>excludeEnd("ctx");
  121. return $recv(self._valuable())._receiver();
  122. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  123. }, function($ctx1) {$ctx1.fill(self,"receiver",{},$globals.AnnouncementSubscription)});
  124. //>>excludeEnd("ctx");
  125. },
  126. //>>excludeStart("ide", pragmas.excludeIdeData);
  127. args: [],
  128. source: "receiver\x0a\x09^ self valuable receiver",
  129. referencedClasses: [],
  130. //>>excludeEnd("ide");
  131. messageSends: ["receiver", "valuable"]
  132. }),
  133. $globals.AnnouncementSubscription);
  134. $core.addMethod(
  135. $core.method({
  136. selector: "valuable",
  137. protocol: 'accessing',
  138. fn: function (){
  139. var self=this;
  140. return self["@valuable"];
  141. },
  142. //>>excludeStart("ide", pragmas.excludeIdeData);
  143. args: [],
  144. source: "valuable\x0a\x09^ valuable",
  145. referencedClasses: [],
  146. //>>excludeEnd("ide");
  147. messageSends: []
  148. }),
  149. $globals.AnnouncementSubscription);
  150. $core.addMethod(
  151. $core.method({
  152. selector: "valuable:",
  153. protocol: 'accessing',
  154. fn: function (aValuable){
  155. var self=this;
  156. self["@valuable"]=aValuable;
  157. return self;
  158. },
  159. //>>excludeStart("ide", pragmas.excludeIdeData);
  160. args: ["aValuable"],
  161. source: "valuable: aValuable\x0a\x09valuable := aValuable",
  162. referencedClasses: [],
  163. //>>excludeEnd("ide");
  164. messageSends: []
  165. }),
  166. $globals.AnnouncementSubscription);
  167. $core.addClass('AnnouncementValuable', $globals.Object, ['valuable', 'receiver'], 'Kernel-Announcements');
  168. //>>excludeStart("ide", pragmas.excludeIdeData);
  169. $globals.AnnouncementValuable.comment="I wrap `valuable` objects (typically instances of `BlockClosure`) with a `receiver` to be able to unregister subscriptions based on a `receiver`.";
  170. //>>excludeEnd("ide");
  171. $core.addMethod(
  172. $core.method({
  173. selector: "receiver",
  174. protocol: 'accessing',
  175. fn: function (){
  176. var self=this;
  177. return self["@receiver"];
  178. },
  179. //>>excludeStart("ide", pragmas.excludeIdeData);
  180. args: [],
  181. source: "receiver\x0a\x09^ receiver",
  182. referencedClasses: [],
  183. //>>excludeEnd("ide");
  184. messageSends: []
  185. }),
  186. $globals.AnnouncementValuable);
  187. $core.addMethod(
  188. $core.method({
  189. selector: "receiver:",
  190. protocol: 'accessing',
  191. fn: function (anObject){
  192. var self=this;
  193. self["@receiver"]=anObject;
  194. return self;
  195. },
  196. //>>excludeStart("ide", pragmas.excludeIdeData);
  197. args: ["anObject"],
  198. source: "receiver: anObject\x0a\x09receiver := anObject",
  199. referencedClasses: [],
  200. //>>excludeEnd("ide");
  201. messageSends: []
  202. }),
  203. $globals.AnnouncementValuable);
  204. $core.addMethod(
  205. $core.method({
  206. selector: "valuable",
  207. protocol: 'accessing',
  208. fn: function (){
  209. var self=this;
  210. return self["@valuable"];
  211. },
  212. //>>excludeStart("ide", pragmas.excludeIdeData);
  213. args: [],
  214. source: "valuable\x0a\x09^ valuable",
  215. referencedClasses: [],
  216. //>>excludeEnd("ide");
  217. messageSends: []
  218. }),
  219. $globals.AnnouncementValuable);
  220. $core.addMethod(
  221. $core.method({
  222. selector: "valuable:",
  223. protocol: 'accessing',
  224. fn: function (anObject){
  225. var self=this;
  226. self["@valuable"]=anObject;
  227. return self;
  228. },
  229. //>>excludeStart("ide", pragmas.excludeIdeData);
  230. args: ["anObject"],
  231. source: "valuable: anObject\x0a\x09valuable := anObject",
  232. referencedClasses: [],
  233. //>>excludeEnd("ide");
  234. messageSends: []
  235. }),
  236. $globals.AnnouncementValuable);
  237. $core.addMethod(
  238. $core.method({
  239. selector: "value",
  240. protocol: 'evaluating',
  241. fn: function (){
  242. var self=this;
  243. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  244. return $core.withContext(function($ctx1) {
  245. //>>excludeEnd("ctx");
  246. return $recv(self._valuable())._value();
  247. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  248. }, function($ctx1) {$ctx1.fill(self,"value",{},$globals.AnnouncementValuable)});
  249. //>>excludeEnd("ctx");
  250. },
  251. //>>excludeStart("ide", pragmas.excludeIdeData);
  252. args: [],
  253. source: "value\x0a\x09^ self valuable value",
  254. referencedClasses: [],
  255. //>>excludeEnd("ide");
  256. messageSends: ["value", "valuable"]
  257. }),
  258. $globals.AnnouncementValuable);
  259. $core.addMethod(
  260. $core.method({
  261. selector: "value:",
  262. protocol: 'evaluating',
  263. fn: function (anObject){
  264. var self=this;
  265. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  266. return $core.withContext(function($ctx1) {
  267. //>>excludeEnd("ctx");
  268. return $recv(self._valuable())._value_(anObject);
  269. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  270. }, function($ctx1) {$ctx1.fill(self,"value:",{anObject:anObject},$globals.AnnouncementValuable)});
  271. //>>excludeEnd("ctx");
  272. },
  273. //>>excludeStart("ide", pragmas.excludeIdeData);
  274. args: ["anObject"],
  275. source: "value: anObject\x0a\x09^ self valuable value: anObject",
  276. referencedClasses: [],
  277. //>>excludeEnd("ide");
  278. messageSends: ["value:", "valuable"]
  279. }),
  280. $globals.AnnouncementValuable);
  281. $core.addClass('Announcer', $globals.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
  282. //>>excludeStart("ide", pragmas.excludeIdeData);
  283. $globals.Announcer.comment="I hold annoncement subscriptions (instances of `AnnouncementSubscription`) in a private registry.\x0aI announce (trigger) announces, which are then dispatched to all subscriptions.\x0a\x0aThe code is based on the announcements as [described by Vassili Bykov](http://www.cincomsmalltalk.com/userblogs/vbykov/blogView?searchCategory=Announcements%20Framework).\x0a\x0a## API\x0a\x0aUse `#announce:` to trigger an announcement.\x0a\x0aUse `#on:do:` or `#on:send:to:` to register subscriptions.\x0a\x0aWhen using `#on:send:to:`, unregistration can be done with `#unregister:`.\x0a\x0a## Usage example:\x0a\x0a SystemAnnouncer current\x0a on: ClassAdded\x0a do: [ :ann | window alert: ann theClass name, ' added' ].";
  284. //>>excludeEnd("ide");
  285. $core.addMethod(
  286. $core.method({
  287. selector: "announce:",
  288. protocol: 'announcing',
  289. fn: function (anAnnouncement){
  290. var self=this;
  291. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  292. return $core.withContext(function($ctx1) {
  293. //>>excludeEnd("ctx");
  294. $recv(self["@subscriptions"])._do_((function(each){
  295. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  296. return $core.withContext(function($ctx2) {
  297. //>>excludeEnd("ctx");
  298. return $recv(each)._deliver_(anAnnouncement);
  299. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  300. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
  301. //>>excludeEnd("ctx");
  302. }));
  303. return self;
  304. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  305. }, function($ctx1) {$ctx1.fill(self,"announce:",{anAnnouncement:anAnnouncement},$globals.Announcer)});
  306. //>>excludeEnd("ctx");
  307. },
  308. //>>excludeStart("ide", pragmas.excludeIdeData);
  309. args: ["anAnnouncement"],
  310. source: "announce: anAnnouncement\x0a\x09subscriptions do: [ :each |\x0a\x09\x09each deliver: anAnnouncement ]",
  311. referencedClasses: [],
  312. //>>excludeEnd("ide");
  313. messageSends: ["do:", "deliver:"]
  314. }),
  315. $globals.Announcer);
  316. $core.addMethod(
  317. $core.method({
  318. selector: "initialize",
  319. protocol: 'initialization',
  320. fn: function (){
  321. var self=this;
  322. function $OrderedCollection(){return $globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
  323. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  324. return $core.withContext(function($ctx1) {
  325. //>>excludeEnd("ctx");
  326. (
  327. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  328. $ctx1.supercall = true,
  329. //>>excludeEnd("ctx");
  330. $globals.Announcer.superclass.fn.prototype._initialize.apply($recv(self), []));
  331. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  332. $ctx1.supercall = false;
  333. //>>excludeEnd("ctx");;
  334. self["@subscriptions"]=$recv($OrderedCollection())._new();
  335. return self;
  336. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  337. }, function($ctx1) {$ctx1.fill(self,"initialize",{},$globals.Announcer)});
  338. //>>excludeEnd("ctx");
  339. },
  340. //>>excludeStart("ide", pragmas.excludeIdeData);
  341. args: [],
  342. source: "initialize\x0a\x09super initialize.\x0a\x09subscriptions := OrderedCollection new",
  343. referencedClasses: ["OrderedCollection"],
  344. //>>excludeEnd("ide");
  345. messageSends: ["initialize", "new"]
  346. }),
  347. $globals.Announcer);
  348. $core.addMethod(
  349. $core.method({
  350. selector: "on:do:",
  351. protocol: 'subscribing',
  352. fn: function (aClass,aBlock){
  353. var self=this;
  354. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  355. return $core.withContext(function($ctx1) {
  356. //>>excludeEnd("ctx");
  357. self._on_do_for_(aClass,aBlock,nil);
  358. return self;
  359. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  360. }, function($ctx1) {$ctx1.fill(self,"on:do:",{aClass:aClass,aBlock:aBlock},$globals.Announcer)});
  361. //>>excludeEnd("ctx");
  362. },
  363. //>>excludeStart("ide", pragmas.excludeIdeData);
  364. args: ["aClass", "aBlock"],
  365. source: "on: aClass do: aBlock\x0a\x09self on: aClass do: aBlock for: nil",
  366. referencedClasses: [],
  367. //>>excludeEnd("ide");
  368. messageSends: ["on:do:for:"]
  369. }),
  370. $globals.Announcer);
  371. $core.addMethod(
  372. $core.method({
  373. selector: "on:do:for:",
  374. protocol: 'subscribing',
  375. fn: function (aClass,aBlock,aReceiver){
  376. var self=this;
  377. function $AnnouncementSubscription(){return $globals.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
  378. function $AnnouncementValuable(){return $globals.AnnouncementValuable||(typeof AnnouncementValuable=="undefined"?nil:AnnouncementValuable)}
  379. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  380. return $core.withContext(function($ctx1) {
  381. //>>excludeEnd("ctx");
  382. var $1,$3,$4,$6,$7,$5,$2;
  383. $1=self["@subscriptions"];
  384. $3=$recv($AnnouncementSubscription())._new();
  385. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  386. $ctx1.sendIdx["new"]=1;
  387. //>>excludeEnd("ctx");
  388. $4=$3;
  389. $6=$recv($AnnouncementValuable())._new();
  390. $recv($6)._valuable_(aBlock);
  391. $recv($6)._receiver_(aReceiver);
  392. $7=$recv($6)._yourself();
  393. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  394. $ctx1.sendIdx["yourself"]=1;
  395. //>>excludeEnd("ctx");
  396. $5=$7;
  397. $recv($4)._valuable_($5);
  398. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  399. $ctx1.sendIdx["valuable:"]=1;
  400. //>>excludeEnd("ctx");
  401. $recv($3)._announcementClass_(aClass);
  402. $2=$recv($3)._yourself();
  403. $recv($1)._add_($2);
  404. return self;
  405. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  406. }, function($ctx1) {$ctx1.fill(self,"on:do:for:",{aClass:aClass,aBlock:aBlock,aReceiver:aReceiver},$globals.Announcer)});
  407. //>>excludeEnd("ctx");
  408. },
  409. //>>excludeStart("ide", pragmas.excludeIdeData);
  410. args: ["aClass", "aBlock", "aReceiver"],
  411. source: "on: aClass do: aBlock for: aReceiver\x0a\x09subscriptions add: (AnnouncementSubscription new\x0a\x09\x09valuable: (AnnouncementValuable new\x0a\x09\x09\x09valuable: aBlock;\x0a\x09\x09\x09receiver: aReceiver;\x0a\x09\x09\x09yourself);\x0a\x09\x09announcementClass: aClass;\x0a\x09\x09yourself)",
  412. referencedClasses: ["AnnouncementSubscription", "AnnouncementValuable"],
  413. //>>excludeEnd("ide");
  414. messageSends: ["add:", "valuable:", "new", "receiver:", "yourself", "announcementClass:"]
  415. }),
  416. $globals.Announcer);
  417. $core.addMethod(
  418. $core.method({
  419. selector: "on:doOnce:",
  420. protocol: 'subscribing',
  421. fn: function (aClass,aBlock){
  422. var self=this;
  423. var subscription;
  424. function $AnnouncementSubscription(){return $globals.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
  425. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  426. return $core.withContext(function($ctx1) {
  427. //>>excludeEnd("ctx");
  428. var $1;
  429. $1=$recv($AnnouncementSubscription())._new();
  430. $recv($1)._announcementClass_(aClass);
  431. subscription=$recv($1)._yourself();
  432. $recv(subscription)._valuable_((function(ann){
  433. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  434. return $core.withContext(function($ctx2) {
  435. //>>excludeEnd("ctx");
  436. $recv(self["@subscriptions"])._remove_(subscription);
  437. return $recv(aBlock)._value_(ann);
  438. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  439. }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,1)});
  440. //>>excludeEnd("ctx");
  441. }));
  442. $recv(self["@subscriptions"])._add_(subscription);
  443. return self;
  444. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  445. }, function($ctx1) {$ctx1.fill(self,"on:doOnce:",{aClass:aClass,aBlock:aBlock,subscription:subscription},$globals.Announcer)});
  446. //>>excludeEnd("ctx");
  447. },
  448. //>>excludeStart("ide", pragmas.excludeIdeData);
  449. args: ["aClass", "aBlock"],
  450. source: "on: aClass doOnce: aBlock\x0a\x09| subscription |\x0a\x09\x0a\x09subscription := AnnouncementSubscription new\x0a\x09\x09announcementClass: aClass;\x0a\x09\x09yourself.\x0a\x09subscription valuable: [ :ann |\x0a\x09\x09subscriptions remove: subscription.\x0a\x09\x09aBlock value: ann ].\x0a\x0a\x09subscriptions add: subscription",
  451. referencedClasses: ["AnnouncementSubscription"],
  452. //>>excludeEnd("ide");
  453. messageSends: ["announcementClass:", "new", "yourself", "valuable:", "remove:", "value:", "add:"]
  454. }),
  455. $globals.Announcer);
  456. $core.addMethod(
  457. $core.method({
  458. selector: "on:send:to:",
  459. protocol: 'subscribing',
  460. fn: function (aClass,aSelector,anObject){
  461. var self=this;
  462. function $AnnouncementSubscription(){return $globals.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
  463. function $MessageSend(){return $globals.MessageSend||(typeof MessageSend=="undefined"?nil:MessageSend)}
  464. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  465. return $core.withContext(function($ctx1) {
  466. //>>excludeEnd("ctx");
  467. var $1,$3,$4,$6,$7,$5,$2;
  468. $1=self["@subscriptions"];
  469. $3=$recv($AnnouncementSubscription())._new();
  470. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  471. $ctx1.sendIdx["new"]=1;
  472. //>>excludeEnd("ctx");
  473. $4=$3;
  474. $6=$recv($MessageSend())._new();
  475. $recv($6)._receiver_(anObject);
  476. $recv($6)._selector_(aSelector);
  477. $7=$recv($6)._yourself();
  478. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  479. $ctx1.sendIdx["yourself"]=1;
  480. //>>excludeEnd("ctx");
  481. $5=$7;
  482. $recv($4)._valuable_($5);
  483. $recv($3)._announcementClass_(aClass);
  484. $2=$recv($3)._yourself();
  485. $recv($1)._add_($2);
  486. return self;
  487. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  488. }, function($ctx1) {$ctx1.fill(self,"on:send:to:",{aClass:aClass,aSelector:aSelector,anObject:anObject},$globals.Announcer)});
  489. //>>excludeEnd("ctx");
  490. },
  491. //>>excludeStart("ide", pragmas.excludeIdeData);
  492. args: ["aClass", "aSelector", "anObject"],
  493. source: "on: aClass send: aSelector to: anObject\x0a\x09subscriptions add: (AnnouncementSubscription new\x0a\x09\x09valuable: (MessageSend new\x0a\x09\x09\x09receiver: anObject;\x0a\x09\x09\x09selector: aSelector;\x0a\x09\x09\x09yourself);\x0a\x09\x09announcementClass: aClass;\x0a\x09\x09yourself)",
  494. referencedClasses: ["AnnouncementSubscription", "MessageSend"],
  495. //>>excludeEnd("ide");
  496. messageSends: ["add:", "valuable:", "new", "receiver:", "selector:", "yourself", "announcementClass:"]
  497. }),
  498. $globals.Announcer);
  499. $core.addMethod(
  500. $core.method({
  501. selector: "unsubscribe:",
  502. protocol: 'subscribing',
  503. fn: function (anObject){
  504. var self=this;
  505. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  506. return $core.withContext(function($ctx1) {
  507. //>>excludeEnd("ctx");
  508. self["@subscriptions"]=$recv(self["@subscriptions"])._reject_((function(each){
  509. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  510. return $core.withContext(function($ctx2) {
  511. //>>excludeEnd("ctx");
  512. return $recv($recv(each)._receiver()).__eq(anObject);
  513. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  514. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
  515. //>>excludeEnd("ctx");
  516. }));
  517. return self;
  518. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  519. }, function($ctx1) {$ctx1.fill(self,"unsubscribe:",{anObject:anObject},$globals.Announcer)});
  520. //>>excludeEnd("ctx");
  521. },
  522. //>>excludeStart("ide", pragmas.excludeIdeData);
  523. args: ["anObject"],
  524. source: "unsubscribe: anObject\x0a\x09subscriptions := subscriptions reject: [ :each |\x0a\x09\x09each receiver = anObject ]",
  525. referencedClasses: [],
  526. //>>excludeEnd("ide");
  527. messageSends: ["reject:", "=", "receiver"]
  528. }),
  529. $globals.Announcer);
  530. $core.addClass('SystemAnnouncer', $globals.Announcer, [], 'Kernel-Announcements');
  531. //>>excludeStart("ide", pragmas.excludeIdeData);
  532. $globals.SystemAnnouncer.comment="My unique instance is the global announcer handling all Amber system-related announces.\x0a\x0a## API\x0a\x0aAccess to the unique instance is done via `#current`";
  533. //>>excludeEnd("ide");
  534. $globals.SystemAnnouncer.klass.iVarNames = ['current'];
  535. $core.addMethod(
  536. $core.method({
  537. selector: "current",
  538. protocol: 'accessing',
  539. fn: function (){
  540. var self=this;
  541. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  542. return $core.withContext(function($ctx1) {
  543. //>>excludeEnd("ctx");
  544. var $1,$receiver;
  545. $1=self["@current"];
  546. if(($receiver = $1) == null || $receiver.isNil){
  547. self["@current"]=(
  548. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  549. $ctx1.supercall = true,
  550. //>>excludeEnd("ctx");
  551. $globals.SystemAnnouncer.klass.superclass.fn.prototype._new.apply($recv(self), []));
  552. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  553. $ctx1.supercall = false;
  554. //>>excludeEnd("ctx");;
  555. return self["@current"];
  556. } else {
  557. return $1;
  558. };
  559. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  560. }, function($ctx1) {$ctx1.fill(self,"current",{},$globals.SystemAnnouncer.klass)});
  561. //>>excludeEnd("ctx");
  562. },
  563. //>>excludeStart("ide", pragmas.excludeIdeData);
  564. args: [],
  565. source: "current\x0a\x09^ current ifNil: [ current := super new ]",
  566. referencedClasses: [],
  567. //>>excludeEnd("ide");
  568. messageSends: ["ifNil:", "new"]
  569. }),
  570. $globals.SystemAnnouncer.klass);
  571. $core.addMethod(
  572. $core.method({
  573. selector: "new",
  574. protocol: 'instance creation',
  575. fn: function (){
  576. var self=this;
  577. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  578. return $core.withContext(function($ctx1) {
  579. //>>excludeEnd("ctx");
  580. self._shouldNotImplement();
  581. return self;
  582. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  583. }, function($ctx1) {$ctx1.fill(self,"new",{},$globals.SystemAnnouncer.klass)});
  584. //>>excludeEnd("ctx");
  585. },
  586. //>>excludeStart("ide", pragmas.excludeIdeData);
  587. args: [],
  588. source: "new\x0a\x09self shouldNotImplement",
  589. referencedClasses: [],
  590. //>>excludeEnd("ide");
  591. messageSends: ["shouldNotImplement"]
  592. }),
  593. $globals.SystemAnnouncer.klass);
  594. $core.addClass('SystemAnnouncement', $globals.Object, [], 'Kernel-Announcements');
  595. //>>excludeStart("ide", pragmas.excludeIdeData);
  596. $globals.SystemAnnouncement.comment="I am the superclass of all system announcements";
  597. //>>excludeEnd("ide");
  598. $core.addMethod(
  599. $core.method({
  600. selector: "classTag",
  601. protocol: 'accessing',
  602. fn: function (){
  603. var self=this;
  604. return "announcement";
  605. },
  606. //>>excludeStart("ide", pragmas.excludeIdeData);
  607. args: [],
  608. source: "classTag\x0a\x09\x22Returns a tag or general category for this class.\x0a\x09Typically used to help tools do some reflection.\x0a\x09Helios, for example, uses this to decide what icon the class should display.\x22\x0a\x09\x0a\x09^ 'announcement'",
  609. referencedClasses: [],
  610. //>>excludeEnd("ide");
  611. messageSends: []
  612. }),
  613. $globals.SystemAnnouncement.klass);
  614. $core.addClass('ClassAnnouncement', $globals.SystemAnnouncement, ['theClass'], 'Kernel-Announcements');
  615. //>>excludeStart("ide", pragmas.excludeIdeData);
  616. $globals.ClassAnnouncement.comment="I am the abstract superclass of class-related announcements.";
  617. //>>excludeEnd("ide");
  618. $core.addMethod(
  619. $core.method({
  620. selector: "theClass",
  621. protocol: 'accessing',
  622. fn: function (){
  623. var self=this;
  624. return self["@theClass"];
  625. },
  626. //>>excludeStart("ide", pragmas.excludeIdeData);
  627. args: [],
  628. source: "theClass\x0a\x09^ theClass",
  629. referencedClasses: [],
  630. //>>excludeEnd("ide");
  631. messageSends: []
  632. }),
  633. $globals.ClassAnnouncement);
  634. $core.addMethod(
  635. $core.method({
  636. selector: "theClass:",
  637. protocol: 'accessing',
  638. fn: function (aClass){
  639. var self=this;
  640. self["@theClass"]=aClass;
  641. return self;
  642. },
  643. //>>excludeStart("ide", pragmas.excludeIdeData);
  644. args: ["aClass"],
  645. source: "theClass: aClass\x0a\x09theClass := aClass",
  646. referencedClasses: [],
  647. //>>excludeEnd("ide");
  648. messageSends: []
  649. }),
  650. $globals.ClassAnnouncement);
  651. $core.addClass('ClassAdded', $globals.ClassAnnouncement, [], 'Kernel-Announcements');
  652. //>>excludeStart("ide", pragmas.excludeIdeData);
  653. $globals.ClassAdded.comment="I am emitted when a class is added to the system.\x0aSee ClassBuilder >> #addSubclassOf:... methods";
  654. //>>excludeEnd("ide");
  655. $core.addClass('ClassCommentChanged', $globals.ClassAnnouncement, [], 'Kernel-Announcements');
  656. //>>excludeStart("ide", pragmas.excludeIdeData);
  657. $globals.ClassCommentChanged.comment="I am emitted when the comment of a class changes. (Behavior >> #comment)";
  658. //>>excludeEnd("ide");
  659. $core.addClass('ClassDefinitionChanged', $globals.ClassAnnouncement, [], 'Kernel-Announcements');
  660. //>>excludeStart("ide", pragmas.excludeIdeData);
  661. $globals.ClassDefinitionChanged.comment="I am emitted when the definition of a class changes.\x0aSee ClassBuilder >> #class:instanceVariableNames:";
  662. //>>excludeEnd("ide");
  663. $core.addClass('ClassMigrated', $globals.ClassAnnouncement, ['oldClass'], 'Kernel-Announcements');
  664. //>>excludeStart("ide", pragmas.excludeIdeData);
  665. $globals.ClassMigrated.comment="I am emitted when a class is migrated.";
  666. //>>excludeEnd("ide");
  667. $core.addMethod(
  668. $core.method({
  669. selector: "oldClass",
  670. protocol: 'accessing',
  671. fn: function (){
  672. var self=this;
  673. return self["@oldClass"];
  674. },
  675. //>>excludeStart("ide", pragmas.excludeIdeData);
  676. args: [],
  677. source: "oldClass\x0a\x09^ oldClass",
  678. referencedClasses: [],
  679. //>>excludeEnd("ide");
  680. messageSends: []
  681. }),
  682. $globals.ClassMigrated);
  683. $core.addMethod(
  684. $core.method({
  685. selector: "oldClass:",
  686. protocol: 'accessing',
  687. fn: function (aClass){
  688. var self=this;
  689. self["@oldClass"]=aClass;
  690. return self;
  691. },
  692. //>>excludeStart("ide", pragmas.excludeIdeData);
  693. args: ["aClass"],
  694. source: "oldClass: aClass\x0a\x09oldClass := aClass",
  695. referencedClasses: [],
  696. //>>excludeEnd("ide");
  697. messageSends: []
  698. }),
  699. $globals.ClassMigrated);
  700. $core.addClass('ClassMoved', $globals.ClassAnnouncement, ['oldPackage'], 'Kernel-Announcements');
  701. //>>excludeStart("ide", pragmas.excludeIdeData);
  702. $globals.ClassMoved.comment="I am emitted when a class is moved from one package to another.";
  703. //>>excludeEnd("ide");
  704. $core.addMethod(
  705. $core.method({
  706. selector: "oldPackage",
  707. protocol: 'accessing',
  708. fn: function (){
  709. var self=this;
  710. return self["@oldPackage"];
  711. },
  712. //>>excludeStart("ide", pragmas.excludeIdeData);
  713. args: [],
  714. source: "oldPackage\x0a\x09^ oldPackage",
  715. referencedClasses: [],
  716. //>>excludeEnd("ide");
  717. messageSends: []
  718. }),
  719. $globals.ClassMoved);
  720. $core.addMethod(
  721. $core.method({
  722. selector: "oldPackage:",
  723. protocol: 'accessing',
  724. fn: function (aPackage){
  725. var self=this;
  726. self["@oldPackage"]=aPackage;
  727. return self;
  728. },
  729. //>>excludeStart("ide", pragmas.excludeIdeData);
  730. args: ["aPackage"],
  731. source: "oldPackage: aPackage\x0a\x09oldPackage := aPackage",
  732. referencedClasses: [],
  733. //>>excludeEnd("ide");
  734. messageSends: []
  735. }),
  736. $globals.ClassMoved);
  737. $core.addClass('ClassRemoved', $globals.ClassAnnouncement, [], 'Kernel-Announcements');
  738. //>>excludeStart("ide", pragmas.excludeIdeData);
  739. $globals.ClassRemoved.comment="I am emitted when a class is removed.\x0aSee Smalltalk >> #removeClass:";
  740. //>>excludeEnd("ide");
  741. $core.addClass('ClassRenamed', $globals.ClassAnnouncement, [], 'Kernel-Announcements');
  742. //>>excludeStart("ide", pragmas.excludeIdeData);
  743. $globals.ClassRenamed.comment="I am emitted when a class is renamed.\x0aSee ClassBuilder >> #renameClass:to:";
  744. //>>excludeEnd("ide");
  745. $core.addClass('MethodAnnouncement', $globals.SystemAnnouncement, ['method'], 'Kernel-Announcements');
  746. //>>excludeStart("ide", pragmas.excludeIdeData);
  747. $globals.MethodAnnouncement.comment="I am the abstract superclass of method-related announcements.";
  748. //>>excludeEnd("ide");
  749. $core.addMethod(
  750. $core.method({
  751. selector: "method",
  752. protocol: 'accessing',
  753. fn: function (){
  754. var self=this;
  755. return self["@method"];
  756. },
  757. //>>excludeStart("ide", pragmas.excludeIdeData);
  758. args: [],
  759. source: "method\x0a\x09^ method",
  760. referencedClasses: [],
  761. //>>excludeEnd("ide");
  762. messageSends: []
  763. }),
  764. $globals.MethodAnnouncement);
  765. $core.addMethod(
  766. $core.method({
  767. selector: "method:",
  768. protocol: 'accessing',
  769. fn: function (aCompiledMethod){
  770. var self=this;
  771. self["@method"]=aCompiledMethod;
  772. return self;
  773. },
  774. //>>excludeStart("ide", pragmas.excludeIdeData);
  775. args: ["aCompiledMethod"],
  776. source: "method: aCompiledMethod\x0a\x09method := aCompiledMethod",
  777. referencedClasses: [],
  778. //>>excludeEnd("ide");
  779. messageSends: []
  780. }),
  781. $globals.MethodAnnouncement);
  782. $core.addClass('MethodAdded', $globals.MethodAnnouncement, [], 'Kernel-Announcements');
  783. //>>excludeStart("ide", pragmas.excludeIdeData);
  784. $globals.MethodAdded.comment="I am emitted when a `CompiledMethod` is added to a class.";
  785. //>>excludeEnd("ide");
  786. $core.addClass('MethodModified', $globals.MethodAnnouncement, ['oldMethod'], 'Kernel-Announcements');
  787. //>>excludeStart("ide", pragmas.excludeIdeData);
  788. $globals.MethodModified.comment="I am emitted when a `CompiledMethod` is modified (a new method is installed). I hold a reference to the old method being replaced.";
  789. //>>excludeEnd("ide");
  790. $core.addMethod(
  791. $core.method({
  792. selector: "oldMethod",
  793. protocol: 'accessing',
  794. fn: function (){
  795. var self=this;
  796. return self["@oldMethod"];
  797. },
  798. //>>excludeStart("ide", pragmas.excludeIdeData);
  799. args: [],
  800. source: "oldMethod\x0a\x09^ oldMethod",
  801. referencedClasses: [],
  802. //>>excludeEnd("ide");
  803. messageSends: []
  804. }),
  805. $globals.MethodModified);
  806. $core.addMethod(
  807. $core.method({
  808. selector: "oldMethod:",
  809. protocol: 'accessing',
  810. fn: function (aMethod){
  811. var self=this;
  812. self["@oldMethod"]=aMethod;
  813. return self;
  814. },
  815. //>>excludeStart("ide", pragmas.excludeIdeData);
  816. args: ["aMethod"],
  817. source: "oldMethod: aMethod\x0a\x09oldMethod := aMethod",
  818. referencedClasses: [],
  819. //>>excludeEnd("ide");
  820. messageSends: []
  821. }),
  822. $globals.MethodModified);
  823. $core.addClass('MethodMoved', $globals.MethodAnnouncement, ['oldProtocol'], 'Kernel-Announcements');
  824. //>>excludeStart("ide", pragmas.excludeIdeData);
  825. $globals.MethodMoved.comment="I am emitted when a `CompiledMethod` is moved to another protocol. I hold a refernce to the old protocol of the method.";
  826. //>>excludeEnd("ide");
  827. $core.addMethod(
  828. $core.method({
  829. selector: "oldProtocol",
  830. protocol: 'accessing',
  831. fn: function (){
  832. var self=this;
  833. return self["@oldProtocol"];
  834. },
  835. //>>excludeStart("ide", pragmas.excludeIdeData);
  836. args: [],
  837. source: "oldProtocol\x0a\x09^ oldProtocol",
  838. referencedClasses: [],
  839. //>>excludeEnd("ide");
  840. messageSends: []
  841. }),
  842. $globals.MethodMoved);
  843. $core.addMethod(
  844. $core.method({
  845. selector: "oldProtocol:",
  846. protocol: 'accessing',
  847. fn: function (aString){
  848. var self=this;
  849. self["@oldProtocol"]=aString;
  850. return self;
  851. },
  852. //>>excludeStart("ide", pragmas.excludeIdeData);
  853. args: ["aString"],
  854. source: "oldProtocol: aString\x0a\x09oldProtocol := aString",
  855. referencedClasses: [],
  856. //>>excludeEnd("ide");
  857. messageSends: []
  858. }),
  859. $globals.MethodMoved);
  860. $core.addClass('MethodRemoved', $globals.MethodAnnouncement, [], 'Kernel-Announcements');
  861. //>>excludeStart("ide", pragmas.excludeIdeData);
  862. $globals.MethodRemoved.comment="I am emitted when a `CompiledMethod` is removed from a class.";
  863. //>>excludeEnd("ide");
  864. $core.addClass('PackageAnnouncement', $globals.SystemAnnouncement, ['package'], 'Kernel-Announcements');
  865. //>>excludeStart("ide", pragmas.excludeIdeData);
  866. $globals.PackageAnnouncement.comment="I am the abstract superclass of package-related announcements.";
  867. //>>excludeEnd("ide");
  868. $core.addMethod(
  869. $core.method({
  870. selector: "package",
  871. protocol: 'accessing',
  872. fn: function (){
  873. var self=this;
  874. return self["@package"];
  875. },
  876. //>>excludeStart("ide", pragmas.excludeIdeData);
  877. args: [],
  878. source: "package\x0a\x09^ package",
  879. referencedClasses: [],
  880. //>>excludeEnd("ide");
  881. messageSends: []
  882. }),
  883. $globals.PackageAnnouncement);
  884. $core.addMethod(
  885. $core.method({
  886. selector: "package:",
  887. protocol: 'accessing',
  888. fn: function (aPackage){
  889. var self=this;
  890. self["@package"]=aPackage;
  891. return self;
  892. },
  893. //>>excludeStart("ide", pragmas.excludeIdeData);
  894. args: ["aPackage"],
  895. source: "package: aPackage\x0a\x09package := aPackage",
  896. referencedClasses: [],
  897. //>>excludeEnd("ide");
  898. messageSends: []
  899. }),
  900. $globals.PackageAnnouncement);
  901. $core.addClass('PackageAdded', $globals.PackageAnnouncement, [], 'Kernel-Announcements');
  902. //>>excludeStart("ide", pragmas.excludeIdeData);
  903. $globals.PackageAdded.comment="I am emitted when a `Package` is added to the system.";
  904. //>>excludeEnd("ide");
  905. $core.addClass('PackageClean', $globals.PackageAnnouncement, [], 'Kernel-Announcements');
  906. //>>excludeStart("ide", pragmas.excludeIdeData);
  907. $globals.PackageClean.comment="I am emitted when a package is committed and becomes clean.";
  908. //>>excludeEnd("ide");
  909. $core.addClass('PackageDirty', $globals.PackageAnnouncement, [], 'Kernel-Announcements');
  910. //>>excludeStart("ide", pragmas.excludeIdeData);
  911. $globals.PackageDirty.comment="I am emitted when a package becomes dirty.";
  912. //>>excludeEnd("ide");
  913. $core.addClass('PackageRemoved', $globals.PackageAnnouncement, [], 'Kernel-Announcements');
  914. //>>excludeStart("ide", pragmas.excludeIdeData);
  915. $globals.PackageRemoved.comment="I am emitted when a `Package` is removed from the system.";
  916. //>>excludeEnd("ide");
  917. $core.addClass('ProtocolAnnouncement', $globals.SystemAnnouncement, ['theClass', 'protocol'], 'Kernel-Announcements');
  918. //>>excludeStart("ide", pragmas.excludeIdeData);
  919. $globals.ProtocolAnnouncement.comment="I am the abstract superclass of protocol-related announcements.";
  920. //>>excludeEnd("ide");
  921. $core.addMethod(
  922. $core.method({
  923. selector: "package",
  924. protocol: 'accessing',
  925. fn: function (){
  926. var self=this;
  927. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  928. return $core.withContext(function($ctx1) {
  929. //>>excludeEnd("ctx");
  930. var $1,$receiver;
  931. $1=self._theClass();
  932. if(($receiver = $1) == null || $receiver.isNil){
  933. return $1;
  934. } else {
  935. var class_;
  936. class_=$receiver;
  937. return $recv(class_)._packageOfProtocol_(self._protocol());
  938. };
  939. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  940. }, function($ctx1) {$ctx1.fill(self,"package",{},$globals.ProtocolAnnouncement)});
  941. //>>excludeEnd("ctx");
  942. },
  943. //>>excludeStart("ide", pragmas.excludeIdeData);
  944. args: [],
  945. source: "package\x0a\x09\x0a\x09^ self theClass ifNotNil: [ :class | class packageOfProtocol: self protocol ]",
  946. referencedClasses: [],
  947. //>>excludeEnd("ide");
  948. messageSends: ["ifNotNil:", "theClass", "packageOfProtocol:", "protocol"]
  949. }),
  950. $globals.ProtocolAnnouncement);
  951. $core.addMethod(
  952. $core.method({
  953. selector: "protocol",
  954. protocol: 'accessing',
  955. fn: function (){
  956. var self=this;
  957. return self["@protocol"];
  958. },
  959. //>>excludeStart("ide", pragmas.excludeIdeData);
  960. args: [],
  961. source: "protocol\x0a\x09^ protocol",
  962. referencedClasses: [],
  963. //>>excludeEnd("ide");
  964. messageSends: []
  965. }),
  966. $globals.ProtocolAnnouncement);
  967. $core.addMethod(
  968. $core.method({
  969. selector: "protocol:",
  970. protocol: 'accessing',
  971. fn: function (aString){
  972. var self=this;
  973. self["@protocol"]=aString;
  974. return self;
  975. },
  976. //>>excludeStart("ide", pragmas.excludeIdeData);
  977. args: ["aString"],
  978. source: "protocol: aString\x0a\x09protocol := aString",
  979. referencedClasses: [],
  980. //>>excludeEnd("ide");
  981. messageSends: []
  982. }),
  983. $globals.ProtocolAnnouncement);
  984. $core.addMethod(
  985. $core.method({
  986. selector: "theClass",
  987. protocol: 'accessing',
  988. fn: function (){
  989. var self=this;
  990. return self["@theClass"];
  991. },
  992. //>>excludeStart("ide", pragmas.excludeIdeData);
  993. args: [],
  994. source: "theClass\x0a\x09^ theClass",
  995. referencedClasses: [],
  996. //>>excludeEnd("ide");
  997. messageSends: []
  998. }),
  999. $globals.ProtocolAnnouncement);
  1000. $core.addMethod(
  1001. $core.method({
  1002. selector: "theClass:",
  1003. protocol: 'accessing',
  1004. fn: function (aClass){
  1005. var self=this;
  1006. self["@theClass"]=aClass;
  1007. return self;
  1008. },
  1009. //>>excludeStart("ide", pragmas.excludeIdeData);
  1010. args: ["aClass"],
  1011. source: "theClass: aClass\x0a\x09theClass := aClass",
  1012. referencedClasses: [],
  1013. //>>excludeEnd("ide");
  1014. messageSends: []
  1015. }),
  1016. $globals.ProtocolAnnouncement);
  1017. $core.addClass('ProtocolAdded', $globals.ProtocolAnnouncement, [], 'Kernel-Announcements');
  1018. //>>excludeStart("ide", pragmas.excludeIdeData);
  1019. $globals.ProtocolAdded.comment="I am emitted when a protocol is added to a class.";
  1020. //>>excludeEnd("ide");
  1021. $core.addClass('ProtocolRemoved', $globals.ProtocolAnnouncement, [], 'Kernel-Announcements');
  1022. //>>excludeStart("ide", pragmas.excludeIdeData);
  1023. $globals.ProtocolRemoved.comment="I am emitted when a protocol is removed from a class.";
  1024. //>>excludeEnd("ide");
  1025. });