SCClassLibrary/Common/Control/SystemActions.sc

   1 AbstractSystemAction {
   2
   3         *init {
   4                 this.objects = List.new;
   5         }
   6
   7         *add { arg object;
   8                 if(this.objects.isNil) { this.init }; // lazy init
   9                 if(this.objects.includes(object).not) { this.objects.add(object) }
  10         }
  11
  12         *remove { arg object;
  13                 this.objects.remove(object)
  14         }
  15
  16         *removeAll {
  17                 this.init
  18         }
  19
  20
  21         *objects { ^this.shouldNotImplement(thisMethod) }
  22         *objects_ { arg obj; ^this.shouldNotImplement(thisMethod) }
  23 }
  24
  25
  26
  27 // things to clear when hitting cmd-.
  28
  29 CmdPeriod : AbstractSystemAction {
  30         classvar <>objects;
  31         classvar <era = 0;
  32         classvar <>clearClocks = true;
  33         classvar <>freeServers = true;
  34         classvar <>freeRemote = false;
  35
  36
  37
  38         *doOnce { arg object;
  39                 var f = { this.remove(f); object.doOnCmdPeriod  };
  40                 this.add(f);
  41         }
  42         *run {
  43                 if(clearClocks, {
  44                         SystemClock.clear;
  45                         AppClock.clear;
  46         //              TempoClock.default.clear;
  47                 });
  48
  49                 objects.copy.do({ arg item; item.doOnCmdPeriod;  });
  50
  51                 if(freeServers, {
  52                         Server.freeAll(freeRemote); // stop all sounds on local, or remote servers
  53                         Server.resumeThreads;
  54                 });
  55
  56                 era = era + 1;
  57
  58         }
  59
  60         *hardRun {
  61
  62                 SystemClock.clear;
  63                 AppClock.clear;
  64                 TempoClock.default.clear;
  65
  66                 objects.copy.do({ arg item; item.doOnCmdPeriod;  });
  67
  68
  69
  70                 Server.hardFreeAll; // stop all sounds on local servers
  71                 Server.resumeThreads;
  72                 era = era + 1;
  73
  74         }
  75
  76
  77 }
  78
  79
  80 // things to do after startup file executed
  81
  82 StartUp : AbstractSystemAction {
  83
  84
  85         classvar <>objects, <done=false;
  86
  87
  88         *run {
  89                 done = true;
  90                 objects.copy.do({ arg item; item.doOnStartUp  });
  91                 // "StartUp done.".postln;
  92         }
  93
  94
  95         *defer { arg object;
  96                  if(done) { object.doOnStartUp } { this.add(object) }
  97         }
  98
  99
 100 }
 101
 102
 103 // things to do before system shuts down
 104
 105 ShutDown : AbstractSystemAction {
 106
 107         classvar <>objects;
 108
 109         *initClass {
 110                 UI.registerForShutdown({ this.run });
 111         }
 112
 113         *run {
 114                 objects.copy.do({ arg item; item.doOnShutDown;  });
 115         //      "ShutDown done.".postln;
 116         }
 117
 118 }
 119
 120
 121 AbstractServerAction : AbstractSystemAction {
 122
 123         *init {
 124                 this.objects = IdentityDictionary.new;
 125         }
 126
 127         *performFunction { arg server, function;
 128                 this.objects.at(server).copy.do(function);
 129                 if(server === Server.default) {
 130                         this.objects.at(\default).copy.do(function)
 131                 };
 132                 this.objects.at(\all).copy.do(function);
 133         }
 134
 135         *run { arg server;
 136                 var selector = this.functionSelector;
 137                 // selector.postln;
 138                 this.performFunction(server, { arg obj; obj.perform(selector, server) });
 139         }
 140
 141         *functionSelector {
 142                 ^this.subclassResponsibility(thisMethod)
 143         }
 144
 145         *add { arg object, server;
 146                 var list;
 147                 if(server.isNil) { server = \default };
 148                 list = this.objects.at(server);
 149                 if(list.isNil) { list = List.new; this.objects.put(server, list) };
 150                 if (list.includes(object).not) { list.add(object) };
 151
 152         }
 153
 154         *addToAll { arg object;
 155
 156                 Server.set.do({ arg s; this.add(object, s) });
 157
 158         }
 159
 160         *remove { arg object, server;
 161
 162                 if(server.isNil) { server = \default };
 163                 this.objects.at(server).remove(object);
 164
 165         }
 166
 167         *removeServer { arg server;
 168                 this.objects.removeAt(server)
 169         }
 170
 171 }
 172
 173 // things to do after server has booted
 174
 175
 176 ServerBoot : AbstractServerAction {
 177
 178         classvar <>objects;
 179
 180         *initClass {
 181                 this.objects = IdentityDictionary.new;
 182         }
 183
 184         *functionSelector {
 185                 ^\doOnServerBoot
 186         }
 187
 188 }
 189
 190 // things to do after server has quit
 191
 192
 193 ServerQuit : AbstractServerAction {
 194
 195         classvar <>objects;
 196
 197         *initClass {
 198                 this.objects = IdentityDictionary.new;
 199         }
 200
 201         *functionSelector {
 202                 ^\doOnServerQuit
 203         }
 204
 205 }
 206
 207
 208 // things to do after server has booted and initialised
 209
 210
 211 ServerTree : AbstractServerAction {
 212
 213
 214         classvar <>objects;
 215
 216
 217         *initClass {
 218                 this.objects = IdentityDictionary.new;
 219         }
 220
 221         *functionSelector {
 222                 ^\doOnServerTree
 223         }
 224
 225 }