← Back to branch summary

~ubuntu-branches/ubuntu/quantal/muse/quantal

« back to all changes in this revision

Viewing changes to share/pybridge/museplauncher.py

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2011-08-12 11:16:41 UTC
  • mto: (1.1.9) (10.1.6 sid)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: james.westby@ubuntu.com-20110812111641-72iatqb9jomjejko
Import upstream version 2.0~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
share/pybridge/museplauncher.py
 
1
"""
 
2
//=========================================================
 
3
//  MusE
 
4
//  Linux Music Editor
 
5
//  (C) Copyright 2009 Mathias Gyllengahm (lunar_shuttle@users.sf.net)
 
6
//=========================================================
 
7
 
 
8
This file is used by MusE for launching a Pyro name service and connecting a remote object to the global Python functions
 
9
"""
 
10
 
 
11
import Pyro.naming
 
12
import Pyro.core
 
13
from Pyro.errors import PyroError,NamingError
 
14
import sys, time
 
15
import threading
 
16
 
 
17
#
 
18
# Note: this module, 'muse' is activated from within MusE - thus it is not possible to execute the scripts without a running
 
19
# MusE instance
 
20
#
 
21
import muse 
 
22
 
 
23
#
 
24
# Class which implements the functionality that is used remotely. 
 
25
# In short just repeating the global functions in the muse-module
 
26
#
 
27
# TODO: It should be better to skip this class completely by implementing 
 
28
# functionality as a class in pyapi.cpp instead of global functions
 
29
# that need to be wrapped like this
 
30
#
 
31
class MusE:
 
32
      def getCPos(self): # Get current position
 
33
            return muse.getCPos()
 
34
 
 
35
      def startPlay(self): # Start playback
 
36
            return muse.startPlay()
 
37
 
 
38
      def stopPlay(self): # Stop playback
 
39
            return muse.stopPlay()
 
40
 
 
41
      def rewindStart(self): # Rewind current position to start
 
42
            return muse.rewindStart()
 
43
 
 
44
      def getLPos(self): # Get position of left locator
 
45
            return muse.getLPos()
 
46
 
 
47
      def getRPos(self): # Get position of right locator
 
48
            return muse.getRPos()
 
49
 
 
50
      def getTempo(self, tick): #Get tempo at particular tick
 
51
            return muse.getTempo(tick)
 
52
 
 
53
      def getTrackNames(self): # get track names
 
54
            return muse.getTrackNames()
 
55
 
 
56
      def getParts(self, trackname): # get parts in a particular track
 
57
            return muse.getParts(trackname)
 
58
 
 
59
      def createPart(self, trackname, starttick, lenticks, part): # create part in track
 
60
            return muse.createPart(trackname, starttick, lenticks, part)
 
61
 
 
62
      def modifyPart(self, part): # modify a part (the part to be modified is specified by its id
 
63
            return muse.modifyPart((part))
 
64
 
 
65
      def deletePart(self, part): # delete a part
 
66
            return muse.deletePart((part))
 
67
 
 
68
      def getSelectedTrack(self): # get first selected track in arranger window
 
69
            return muse.getSelectedTrack()
 
70
 
 
71
      def importPart(self, trackname, filename, tick): # import part file to a track at a given position
 
72
            return muse.importPart(trackname, filename, tick)
 
73
 
 
74
      def setCPos(self, tick): # set current position
 
75
            return muse.setPos(0, tick)
 
76
 
 
77
      def setLPos(self, tick): # set left locator
 
78
            return muse.setPos(1, tick)
 
79
 
 
80
      def setRPos(self, tick): # set right locator
 
81
            return muse.setPos(2, tick)
 
82
      
 
83
      def setSongLen(self, ticks): # set song length
 
84
            return muse.setSongLen(ticks)
 
85
 
 
86
      def getSongLen(self): # get song length
 
87
            return muse.getSongLen()
 
88
 
 
89
      def getDivision(self): # get division (ticks per 1/4, or per beat?)
 
90
            return muse.getDivision()
 
91
 
 
92
      def setMidiTrackParameter(self, trackname, paramname, value): # set midi track parameter (velocity, compression, len, transpose)
 
93
            return muse.setMidiTrackParameter(trackname, paramname, value);
 
94
 
 
95
      def getLoop(self): # get loop flag
 
96
            return muse.getLoop()
 
97
 
 
98
      def setLoop(self, loopFlag): # set loop flag
 
99
            return muse.setLoop(loopFlag)
 
100
      
 
101
      def getMute(self, trackname): # get track mute parameter
 
102
            return muse.getMute(trackname)
 
103
 
 
104
      def setMute(self, trackname, enabled): # set track mute parameter
 
105
            return muse.setMute(trackname, enabled)
 
106
 
 
107
      def setVolume(self, trackname, volume): # set mixer volume
 
108
            return muse.setVolume(trackname, volume)
 
109
 
 
110
      def getMidiControllerValue(self, trackname, ctrlno): # get a particular midi controller value for a track
 
111
            return muse.getMidiControllerValue(trackname, ctrlno)
 
112
 
 
113
      def setMidiControllerValue(self, trackname, ctrlno, value): # set a particular midi controller value for a track
 
114
            return muse.setMidiControllerValue(trackname, ctrlno, value)
 
115
 
 
116
      def setAudioTrackVolume(self, trackname, dvol): # set volume for audio track 
 
117
            return muse.setAudioTrackVolume(trackname, dvol)
 
118
 
 
119
      def getAudioTrackVolume(self, trackname): # get volume for audio track
 
120
            return muse.getAudioTrackVolume(trackname)
 
121
 
 
122
      def getTrackEffects(self, trackname): # get effect names for an audio track
 
123
            return muse.getTrackEffects(trackname)
 
124
 
 
125
      def toggleTrackEffect(self, trackname, effectno, onoff): # toggle specific effect on/off
 
126
            return muse.toggleTrackEffect(trackname, effectno, onoff)
 
127
 
 
128
      def findNewTrack(self, oldtracknames): #internal function
 
129
            tracknames = muse.getTrackNames()
 
130
            for trackname in tracknames:
 
131
                  if trackname in oldtracknames:
 
132
                        continue
 
133
 
 
134
                  return trackname
 
135
 
 
136
      def changeTrackName(self, trackname, newname): #change track name
 
137
            return muse.changeTrackName(trackname, newname)
 
138
 
 
139
      def nameNewTrack(self, newname, oldtracknames):# Internal function, wait until new track shows up in tracknames, then rename it
 
140
            tmpname = None
 
141
            for i in range(0,100):
 
142
                  tmpname = self.findNewTrack(oldtracknames)
 
143
                  if tmpname == None:
 
144
                        time.sleep(0.1)
 
145
                        continue
 
146
                  else:
 
147
                        self.changeTrackName(tmpname, newname)
 
148
                        time.sleep(0.1) # Ouch!!
 
149
                        break
 
150
 
 
151
 
 
152
      def addMidiTrack(self, trackname): # add midi track
 
153
            oldtracknames = muse.getTrackNames()
 
154
            if trackname in oldtracknames:
 
155
                  return None
 
156
 
 
157
            muse.addMidiTrack()
 
158
            self.nameNewTrack(trackname, oldtracknames)
 
159
            
 
160
 
 
161
      def addWaveTrack(self, trackname): # add wave track
 
162
            oldtracknames = muse.getTrackNames()
 
163
            if trackname in oldtracknames:
 
164
                  return None
 
165
 
 
166
            muse.addWaveTrack()
 
167
            self.nameNewTrack(trackname, oldtracknames)
 
168
 
 
169
      def addInput(self, trackname): # add audio input
 
170
            oldtracknames = muse.getTrackNames()
 
171
            if trackname in oldtracknames:
 
172
                  return None
 
173
 
 
174
            muse.addInput()
 
175
            self.nameNewTrack(trackname, oldtracknames)
 
176
 
 
177
      def addOutput(self, trackname): # add audio output
 
178
            oldtracknames = muse.getTrackNames()
 
179
            if trackname in oldtracknames:
 
180
                  return None
 
181
 
 
182
            muse.addOutput()
 
183
            self.nameNewTrack(trackname, oldtracknames)
 
184
 
 
185
      def addGroup(self, trackname): # add audio group
 
186
            oldtracknames = muse.getTrackNames()
 
187
            if trackname in oldtracknames:
 
188
                  return None
 
189
 
 
190
            muse.addGroup()
 
191
            self.nameNewTrack(trackname, oldtracknames)
 
192
 
 
193
      def deleteTrack(self, trackname): # delete a track
 
194
            tracknames = muse.getTrackNames()
 
195
            if trackname not in tracknames:
 
196
                  return False
 
197
 
 
198
            muse.deleteTrack(trackname)
 
199
 
 
200
#      def getOutputRoute(self, trackname):
 
201
#            return muse.getOutputRoute(trackname)
 
202
 
 
203
class NameServiceThread(threading.Thread):
 
204
      def __init__(self):
 
205
            threading.Thread.__init__(self)
 
206
            self.starter = Pyro.naming.NameServerStarter()
 
207
 
 
208
      def run(self):
 
209
            self.starter.start()
 
210
 
 
211
      def verifyRunning(self):
 
212
            return self.starter.waitUntilStarted(10)
 
213
 
 
214
#
 
215
# museclass Pyro object
 
216
#
 
217
class museclass(Pyro.core.ObjBase, MusE):
 
218
      pass
 
219
 
 
220
#
 
221
# main server program
 
222
#
 
223
def main():
 
224
      Pyro.core.initServer()
 
225
      nsthread = NameServiceThread()
 
226
      nsthread.start()
 
227
      if (nsthread.verifyRunning() == False):
 
228
            print "Failed to launch name service..."
 
229
            sys.exit(1)
 
230
 
 
231
      daemon = Pyro.core.Daemon()
 
232
      # locate the NS
 
233
      locator = Pyro.naming.NameServerLocator()
 
234
      #print 'searching for Name Server...'
 
235
      ns = locator.getNS()
 
236
      daemon.useNameServer(ns)
 
237
 
 
238
      # connect a new object implementation (first unregister previous one)
 
239
      try:
 
240
            # 'test' is the name by which our object will be known to the outside world
 
241
            ns.unregister('muse')
 
242
      except NamingError:
 
243
            pass
 
244
 
 
245
      # connect new object implementation
 
246
      daemon.connect(museclass(),'muse')
 
247
 
 
248
      # enter the server loop.
 
249
      print 'Muse remote object published'
 
250
      daemon.requestLoop()
 
251
 
 
252
if __name__=="__main__":
 
253
        main()
 
254
 
 
255
main()
 
256
 
 
257