You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
510 lines
21 KiB
510 lines
21 KiB
"""
|
|
File:
|
|
JetAudition.py
|
|
|
|
Contents and purpose:
|
|
Auditions a jet file to simulate interactive music functions
|
|
|
|
Copyright (c) 2008 Android Open Source Project
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
"""
|
|
|
|
from __future__ import with_statement
|
|
|
|
import wx
|
|
import sys
|
|
import thread
|
|
import time
|
|
|
|
from JetUtils import *
|
|
from JetDefs import *
|
|
from JetCtrls import JetListCtrl, JetTrackCtrl
|
|
from JetSegGraph import SegmentGraph, Marker
|
|
from eas import *
|
|
from JetStatusEvent import *
|
|
|
|
CMD_QUEUE_AND_CANCEL = 'QueueNCancel'
|
|
CMD_QUEUE_AND_CANCEL_CURRENT = 'QueueCancelCurrent'
|
|
CMD_MUTEALL = 'MuteAll'
|
|
CMD_UNMUTEALL = 'UnMuteAll'
|
|
CMD_ORIGINALMUTES = 'MuteOrg'
|
|
CMD_STOP = 'Stop'
|
|
CMD_PAUSE = 'Pause'
|
|
CMD_PLAY = 'Play'
|
|
|
|
STATUS_PENDING = 'Pending'
|
|
STATUS_PLAYING = 'Playing'
|
|
STATUS_COMPLETE = 'Complete'
|
|
STATUS_CANCELED = 'Canceled'
|
|
STATUS_QUEUED = 'Queued'
|
|
|
|
LOAD_QUEUE_DISPLAY = 'LOAD_QUEUE'
|
|
GRAPH_POSITION_UPDATE = 'GRAPH_POS'
|
|
NEW_SEGMENT_DISPLAY = 'NEW SEG'
|
|
CLR_INFO = 'CLR_INFO'
|
|
|
|
class Audition(wx.Dialog):
|
|
""" Initializes Audition window controls, then spawns off a thread to be ready for playback commands """
|
|
def __init__(self, jet_file, pSize):
|
|
wx.Dialog.__init__(self, None, -1, title=JetDefs.DLG_AUDITION)
|
|
|
|
self.jet = None
|
|
self.playerLock = threading.RLock()
|
|
self.jet_file = jet_file
|
|
self.queueSegs = []
|
|
self.keepPlaying = True
|
|
self.nextSegNum = 0
|
|
self.currentSegmentIndex = None
|
|
self.currentSegmentName = ""
|
|
self.playCommand = ""
|
|
self.threadShutdown = True
|
|
|
|
panel = wx.Panel(self, -1)
|
|
|
|
self.segList = JetListCtrl(panel)
|
|
self.segList.AddCol(JetDefs.GRD_SEGMENTS, 180)
|
|
self.segList.AddCol(JetDefs.GRD_LENGTH, 20)
|
|
|
|
self.segList.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnQueueSegment)
|
|
self.segList.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnSegListClick)
|
|
|
|
self.queueList = JetListCtrl(panel)
|
|
self.queueList.AddCol(JetDefs.GRD_QUEUE, 180)
|
|
self.queueList.AddCol(JetDefs.GRD_STATUS, 20)
|
|
|
|
self.trackList = JetTrackCtrl(panel)
|
|
self.trackList.AddCol(JetDefs.GRD_TRACK, JetDefs.MUTEGRD_TRACK)
|
|
self.trackList.AddCol(JetDefs.GRD_CHANNEL, JetDefs.MUTEGRD_CHANNEL)
|
|
self.trackList.AddCol(JetDefs.GRD_NAME, JetDefs.MUTEGRD_NAME)
|
|
self.trackList.BindCheckBox(self.OnTrackChecked)
|
|
|
|
self.btnMuteAll = wx.Button(panel, -1, JetDefs.BUT_MUTEALL)
|
|
self.btnUnMuteAll = wx.Button(panel, -1, JetDefs.BUT_MUTENONE)
|
|
self.btnMuteOrg = wx.Button(panel, -1, JetDefs.BUT_ORGMUTES)
|
|
hMuteButs = wx.BoxSizer(wx.HORIZONTAL)
|
|
hMuteButs.Add(self.btnMuteAll, 1, wx.EXPAND)
|
|
hMuteButs.Add(self.btnUnMuteAll, 1, wx.EXPAND)
|
|
hMuteButs.Add(self.btnMuteOrg, 1, wx.EXPAND)
|
|
vMuteButs = wx.BoxSizer(wx.VERTICAL)
|
|
vMuteButs.Add(self.trackList, 1, wx.EXPAND)
|
|
vMuteButs.Add((-1, 5))
|
|
vMuteButs.Add(hMuteButs, 0, wx.EXPAND)
|
|
|
|
self.btnQueue = wx.Button(panel, -1, JetDefs.BUT_QUEUE)
|
|
self.btnCancelNQueue = wx.Button(panel, -1, JetDefs.BUT_CANCELANDQUEUE)
|
|
hSegButs = wx.BoxSizer(wx.HORIZONTAL)
|
|
hSegButs.Add(self.btnQueue, 1, wx.EXPAND)
|
|
hSegButs.Add(self.btnCancelNQueue, 1, wx.EXPAND)
|
|
vSegButs = wx.BoxSizer(wx.VERTICAL)
|
|
vSegButs.Add(self.segList, 1, wx.EXPAND)
|
|
vSegButs.Add((-1, 5))
|
|
vSegButs.Add(hSegButs, 0, wx.EXPAND)
|
|
|
|
self.btnQueueCancelCurrent = wx.Button(panel, -1, JetDefs.BUT_CANCELCURRENT)
|
|
self.btnPause = wx.Button(panel, -1, JetDefs.BUT_PAUSE)
|
|
self.btnStop = wx.Button(panel, -1, JetDefs.BUT_STOP)
|
|
hQueueButs = wx.BoxSizer(wx.HORIZONTAL)
|
|
hQueueButs.Add(self.btnQueueCancelCurrent, 1, wx.EXPAND)
|
|
hQueueButs.Add(self.btnPause, 1, wx.EXPAND)
|
|
hQueueButs.Add(self.btnStop, 1, wx.EXPAND)
|
|
vQueueButs = wx.BoxSizer(wx.VERTICAL)
|
|
vQueueButs.Add(self.queueList, 1, wx.EXPAND)
|
|
vQueueButs.Add((-1, 5))
|
|
vQueueButs.Add(hQueueButs, 0, wx.EXPAND)
|
|
|
|
self.Bind(wx.EVT_BUTTON, self.OnQueueSegmentViaBut, id=self.btnQueue.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnCancelNQueue, id=self.btnCancelNQueue.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnStop, id=self.btnStop.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnQueueCancelCurrent, id=self.btnQueueCancelCurrent.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnPause, id=self.btnPause.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnMuteAll, id=self.btnMuteAll.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnUnMuteAll, id=self.btnUnMuteAll.GetId())
|
|
self.Bind(wx.EVT_BUTTON, self.OnMuteOrg, id=self.btnMuteOrg.GetId())
|
|
|
|
EVT_JET_STATUS(self, self.OnJetStatusUpdate)
|
|
|
|
BORDER = 10
|
|
hboxTop = wx.BoxSizer(wx.HORIZONTAL)
|
|
hboxTop.Add(vSegButs, 1, wx.EXPAND)
|
|
hboxTop.Add((5, -1))
|
|
hboxTop.Add(vQueueButs, 1, wx.EXPAND)
|
|
hboxTop.Add((5, -1))
|
|
hboxTop.Add(vMuteButs, 1, wx.EXPAND)
|
|
|
|
self.log = wx.TextCtrl(panel, -1)
|
|
self.graph = SegmentGraph(panel, size=(-1, 50))
|
|
self.graph.ClickCallbackFct = self.GraphTriggerClip
|
|
|
|
vboxBot = wx.BoxSizer(wx.VERTICAL)
|
|
vboxBot.Add(self.log, 0, wx.EXPAND)
|
|
vboxBot.Add((-1, 5))
|
|
vboxBot.Add(self.graph, 1, wx.EXPAND)
|
|
|
|
hboxMain = wx.BoxSizer(wx.VERTICAL)
|
|
hboxMain.Add(hboxTop, 2, wx.EXPAND | wx.ALL, BORDER)
|
|
hboxMain.Add(vboxBot, 1, wx.EXPAND | wx.ALL, BORDER)
|
|
|
|
panel.SetSizer(hboxMain)
|
|
|
|
self.LoadSegList()
|
|
self.initHelp()
|
|
|
|
self.SetSize(pSize)
|
|
self.CenterOnParent()
|
|
|
|
wx.EVT_CLOSE(self, self.OnClose)
|
|
|
|
thread.start_new_thread(self.PlaySegs, ())
|
|
|
|
def initHelp(self):
|
|
""" Initializes context sensitive help text """
|
|
self.SetExtraStyle(wx.DIALOG_EX_CONTEXTHELP )
|
|
self.SetHelpText(GetJetHelpText(JetDefs.AUDITION_CTRLS, ''))
|
|
self.segList.SetHelpText(GetJetHelpText(JetDefs.AUDITION_CTRLS, JetDefs.AUDITION_SEGLIST))
|
|
self.queueList.SetHelpText(GetJetHelpText(JetDefs.AUDITION_CTRLS, JetDefs.AUDITION_QUEUELIST))
|
|
self.trackList.SetHelpText(GetJetHelpText(JetDefs.AUDITION_CTRLS, JetDefs.AUDITION_TRACKLIST))
|
|
self.graph.SetHelpText(GetJetHelpText(JetDefs.AUDITION_CTRLS, JetDefs.AUDITION_GRAPH))
|
|
|
|
def OnMuteAll(self, event):
|
|
""" Sets command to mute all tracks """
|
|
self.SetPlayCommand(CMD_MUTEALL)
|
|
|
|
def OnUnMuteAll(self, event):
|
|
""" Sets command to un-mute all tracks """
|
|
self.SetPlayCommand(CMD_UNMUTEALL)
|
|
|
|
def OnMuteOrg(self, event):
|
|
""" Sets command to set mute flags to their original values """
|
|
self.SetPlayCommand(CMD_ORIGINALMUTES)
|
|
|
|
def OnTrackChecked(self, index, checked):
|
|
""" Mutes or un-mutes a track interactively """
|
|
with self.playerLock:
|
|
trackNum = self.trackList.GetTrackNumber(index)
|
|
self.SetMuteFlag(trackNum, checked)
|
|
|
|
def SetMuteFlag(self, trackNum, mute):
|
|
""" Mutes or un-mutes a track """
|
|
with self.playerLock:
|
|
try:
|
|
sync = JetDefs.DEFAULT_MUTE_SYNC
|
|
self.jet.SetMuteFlag(trackNum, mute, sync)
|
|
logging.info("SetMuteFlag() Track:%d Mute:%d Sync:%d" % (trackNum, mute, sync))
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
def LoadSegList(self):
|
|
""" Loads the list of segments """
|
|
with self.playerLock:
|
|
self.segList.DeleteAllItems()
|
|
for segment in self.jet_file.GetSegments():
|
|
info = MidiSegInfo(segment)
|
|
index = self.segList.InsertStringItem(sys.maxint, StrNoneChk(segment.segname))
|
|
self.segList.SetStringItem(index, 1, TimeStr(info.iLengthInMs))
|
|
|
|
def GraphTriggerClip(self, sClipName, iEventId):
|
|
""" Triggers a clip """
|
|
with self.playerLock:
|
|
try:
|
|
self.jet.TriggerClip(iEventId)
|
|
self.log.SetValue(JetDefs.PLAY_TRIGGERCLIP_MSG % (iEventId, sClipName))
|
|
return True
|
|
except:
|
|
return False
|
|
|
|
def OnSegListClick(self, event):
|
|
""" Sets current segment name based on what's clicked """
|
|
with self.playerLock:
|
|
self.currentSegmentIndex = event.m_itemIndex
|
|
self.currentSegmentName = getColumnText(self.segList, event.m_itemIndex, 0)
|
|
|
|
def OnCancelNQueue(self, event):
|
|
""" Sets command to cancel the currently playing segment and queues another """
|
|
if self.currentSegmentIndex == None:
|
|
return
|
|
self.SetPlayCommand(CMD_QUEUE_AND_CANCEL)
|
|
|
|
def OnPause(self, event):
|
|
""" Sets a command to pause playback """
|
|
if self.currentSegmentIndex == None:
|
|
return
|
|
self.SetPlayCommand(CMD_PAUSE)
|
|
|
|
def OnStop(self, event):
|
|
""" Sets a command to stop playback """
|
|
if self.currentSegmentIndex == None:
|
|
return
|
|
self.SetPlayCommand(CMD_STOP)
|
|
|
|
def OnQueueCancelCurrent(self, event):
|
|
""" Sets a command to cancel the currently playing segment """
|
|
if self.currentSegmentIndex == None:
|
|
return
|
|
self.SetPlayCommand(CMD_QUEUE_AND_CANCEL_CURRENT)
|
|
|
|
def OnQueueSegmentViaBut(self, event):
|
|
""" Queues a segment via the button """
|
|
if self.currentSegmentIndex == None:
|
|
return
|
|
with self.playerLock:
|
|
segNum = self.currentSegmentIndex
|
|
segment = self.jet_file.GetSegment(self.currentSegmentName)
|
|
self.QueueOneSegment(segment, segNum)
|
|
|
|
def OnQueueSegment(self, event):
|
|
""" Queues a segment """
|
|
with self.playerLock:
|
|
segNum = event.m_itemIndex
|
|
segment = self.jet_file.GetSegment(getColumnText(self.segList, segNum, 0))
|
|
self.QueueOneSegment(segment, segNum)
|
|
|
|
def QueueOneSegment(self, segment, segNum):
|
|
""" Queues one segment """
|
|
with self.playerLock:
|
|
userID = len(self.queueSegs)
|
|
if FileExists(segment.dlsfile):
|
|
dls_num = FindDlsNum(self.jet_file.libraries, segment.dlsfile)
|
|
else:
|
|
dls_num = -1
|
|
self.queueSegs.append(QueueSeg(segment.segname, userID, segNum, dls_num, segment.repeat, segment.transpose, segment.mute_flags, STATUS_PENDING))
|
|
self.LoadQueueDisplay()
|
|
|
|
def SetKeepPlayingFlag(self, val):
|
|
""" Sets a flag to continue play loop or shut down """
|
|
with self.playerLock:
|
|
self.keepPlaying = val
|
|
|
|
def GetKeepPlayingFlag(self):
|
|
""" Gets the play flag """
|
|
with self.playerLock:
|
|
return self.keepPlaying
|
|
|
|
def SetThreadShutdownFlag(self, val):
|
|
""" Set a flag to shutdown thread """
|
|
with self.playerLock:
|
|
self.threadShutdown = val
|
|
|
|
def GetThreadShutdownFlag(self):
|
|
""" Gets the thread shutdown flag """
|
|
with self.playerLock:
|
|
return self.threadShutdown
|
|
|
|
def SetPlayCommand(self, cmd):
|
|
""" Sets a play command """
|
|
with self.playerLock:
|
|
self.playCommand = cmd
|
|
|
|
def GetPlayCommand(self):
|
|
""" Gets a play command """
|
|
with self.playerLock:
|
|
return self.playCommand
|
|
|
|
def SetStatus(self, index, status):
|
|
""" Sets the status of a segment """
|
|
with self.playerLock:
|
|
self.queueSegs[index].status = status
|
|
|
|
def GetStatus(self, index):
|
|
""" Gets the status of a segment """
|
|
with self.playerLock:
|
|
return self.queueSegs[index].status
|
|
|
|
def LoadQueueDisplay(self):
|
|
""" Loads up the displayed queue list """
|
|
with self.playerLock:
|
|
self.queueList.DeleteAllItems()
|
|
for item in self.queueSegs:
|
|
index = self.queueList.InsertStringItem(sys.maxint, item.name)
|
|
self.queueList.SetStringItem(index, 1, item.status)
|
|
|
|
def NextSegment(self):
|
|
""" Gets the next segment in the queueu """
|
|
with self.playerLock:
|
|
num = len(self.queueSegs)
|
|
for i in range(num):
|
|
if self.queueSegs[i].status == STATUS_PENDING:
|
|
return i
|
|
return -1
|
|
|
|
def PlaySegs(self):
|
|
""" Sets up a loop looking for jet file actions based on UI commands """
|
|
self.jet = JET()
|
|
self.jet.eas.StartWave()
|
|
self.jet.OpenFile(self.jet_file.config.filename)
|
|
|
|
self.SetKeepPlayingFlag(True)
|
|
while self.GetKeepPlayingFlag():
|
|
self.SetThreadShutdownFlag(False)
|
|
|
|
time.sleep(.5)
|
|
index = self.NextSegment()
|
|
if index != -1:
|
|
lastID = -1
|
|
|
|
Queue(self.jet, self.queueSegs[index])
|
|
|
|
self.SetStatus(index, STATUS_QUEUED)
|
|
|
|
wx.PostEvent(self, JetStatusEvent(LOAD_QUEUE_DISPLAY, None))
|
|
|
|
self.jet.Play()
|
|
self.paused = False
|
|
wx.PostEvent(self, JetStatusEvent(CMD_PLAY, None))
|
|
|
|
while self.GetKeepPlayingFlag():
|
|
self.jet.Render()
|
|
status = self.jet.Status()
|
|
|
|
if status.currentUserID <> lastID and status.currentUserID <> -1:
|
|
wx.PostEvent(self, JetStatusEvent(NEW_SEGMENT_DISPLAY, status.currentUserID))
|
|
if lastID != -1:
|
|
self.SetStatus(lastID, STATUS_COMPLETE)
|
|
self.SetStatus(status.currentUserID, STATUS_PLAYING)
|
|
lastID = status.currentUserID
|
|
wx.PostEvent(self, JetStatusEvent(LOAD_QUEUE_DISPLAY, None))
|
|
|
|
if status.numQueuedSegments == 0:
|
|
break
|
|
|
|
self.jet.GetAppEvent()
|
|
|
|
index = self.NextSegment()
|
|
if (index >= 0) and (status.numQueuedSegments < 2):
|
|
Queue(self.jet, self.queueSegs[index])
|
|
self.SetStatus(index, STATUS_QUEUED)
|
|
wx.PostEvent(self, JetStatusEvent(LOAD_QUEUE_DISPLAY, None))
|
|
|
|
wx.PostEvent(self, JetStatusEvent(GRAPH_POSITION_UPDATE, status.location))
|
|
|
|
playCmd = self.GetPlayCommand()
|
|
if playCmd == CMD_QUEUE_AND_CANCEL or playCmd == CMD_STOP or playCmd == CMD_QUEUE_AND_CANCEL_CURRENT:
|
|
if playCmd == CMD_QUEUE_AND_CANCEL or playCmd == CMD_STOP:
|
|
num = len(self.queueSegs)
|
|
for i in range(num):
|
|
curStatus = self.GetStatus(i)
|
|
if curStatus == STATUS_PENDING or curStatus == STATUS_PLAYING or curStatus == STATUS_QUEUED:
|
|
self.SetStatus(i, STATUS_CANCELED)
|
|
|
|
if playCmd == CMD_QUEUE_AND_CANCEL_CURRENT:
|
|
self.SetStatus(status.currentUserID, STATUS_CANCELED)
|
|
num = len(self.queueSegs)
|
|
for i in range(num):
|
|
curStatus = self.GetStatus(i)
|
|
if curStatus == STATUS_QUEUED:
|
|
self.SetStatus(i, STATUS_PENDING)
|
|
|
|
if playCmd == CMD_QUEUE_AND_CANCEL:
|
|
segNum = self.currentSegmentIndex
|
|
segment = self.jet_file.GetSegment(self.currentSegmentName)
|
|
wx.PostEvent(self, JetStatusEvent(CMD_QUEUE_AND_CANCEL, (segment, segNum)))
|
|
|
|
#MAC has a 'pop' when clearing the queue; not sure why so this avoids it
|
|
if OsWindows():
|
|
self.jet.Clear_Queue()
|
|
else:
|
|
self.jet = self.SafeJetRestart(self.playerLock, self.jet, self.jet_file.config.filename)
|
|
|
|
if playCmd == CMD_ORIGINALMUTES:
|
|
wx.PostEvent(self, JetStatusEvent(CMD_ORIGINALMUTES, segment.mute_flags))
|
|
|
|
if playCmd == CMD_UNMUTEALL:
|
|
wx.PostEvent(self, JetStatusEvent(CMD_UNMUTEALL, None))
|
|
|
|
if playCmd == CMD_PAUSE:
|
|
wx.PostEvent(self, JetStatusEvent(CMD_PAUSE, None))
|
|
|
|
if playCmd == CMD_MUTEALL:
|
|
wx.PostEvent(self, JetStatusEvent(CMD_MUTEALL, None))
|
|
|
|
self.SetPlayCommand('')
|
|
|
|
if self.GetStatus(lastID) != STATUS_CANCELED:
|
|
self.SetStatus(lastID, STATUS_COMPLETE)
|
|
|
|
wx.PostEvent(self, JetStatusEvent(LOAD_QUEUE_DISPLAY, None))
|
|
wx.PostEvent(self, JetStatusEvent(CLR_INFO, None))
|
|
|
|
SafeJetShutdown(self.playerLock, self.jet)
|
|
self.SetThreadShutdownFlag(True)
|
|
|
|
def OnJetStatusUpdate(self, evt):
|
|
""" All UI needed from within thread called via postevent otherwise mac crashes """
|
|
if evt.mode == LOAD_QUEUE_DISPLAY:
|
|
self.LoadQueueDisplay()
|
|
elif evt.mode == GRAPH_POSITION_UPDATE:
|
|
self.graph.UpdateLocation(evt.data)
|
|
elif evt.mode == NEW_SEGMENT_DISPLAY:
|
|
self.currentSegmentName = getColumnText(self.queueList, evt.data, 0)
|
|
segment = self.jet_file.GetSegment(self.currentSegmentName)
|
|
info = self.graph.LoadSegment(segment)
|
|
self.trackList.DeleteAllItems()
|
|
if info <> None:
|
|
for track in info.trackList:
|
|
self.trackList.AddTrackRow(track)
|
|
self.trackList.CheckTracks(segment.mute_flags)
|
|
self.log.SetValue(self.currentSegmentName)
|
|
elif evt.mode == CMD_QUEUE_AND_CANCEL:
|
|
self.QueueOneSegment(evt.data[0], evt.data[1])
|
|
elif evt.mode == CMD_ORIGINALMUTES:
|
|
self.trackList.CheckTracks(evt.data)
|
|
elif evt.mode == CMD_UNMUTEALL:
|
|
num = self.trackList.GetItemCount()
|
|
for i in range(num):
|
|
self.trackList.CheckItem(i, False)
|
|
elif evt.mode == CMD_MUTEALL:
|
|
num = self.trackList.GetItemCount()
|
|
for i in range(num):
|
|
self.trackList.CheckItem(i)
|
|
elif evt.mode == CLR_INFO:
|
|
self.log.SetValue("")
|
|
self.graph.ClearGraph()
|
|
self.graph.UpdateLocation(0)
|
|
elif evt.mode == CMD_PLAY:
|
|
self.btnPause.SetLabel(JetDefs.BUT_PAUSE)
|
|
elif evt.mode == CMD_PAUSE or evt.mode == CMD_PLAY:
|
|
if not self.paused:
|
|
self.jet.Pause()
|
|
self.paused = True
|
|
self.btnPause.SetLabel(JetDefs.BUT_RESUME)
|
|
else:
|
|
self.jet.Play()
|
|
self.paused = False
|
|
self.btnPause.SetLabel(JetDefs.BUT_PAUSE)
|
|
|
|
def SafeJetRestart(self, lock, jet, filename):
|
|
""" Shuts down the jet engine """
|
|
SafeJetShutdown(lock, jet)
|
|
with lock:
|
|
jet = JET()
|
|
jet.eas.StartWave()
|
|
jet.OpenFile(filename)
|
|
return jet
|
|
|
|
def OnClose(self, event):
|
|
""" When exiting the audition window, shut down jet play thread """
|
|
i = 0
|
|
while(not self.GetThreadShutdownFlag() and i < 5):
|
|
#Make sure we shutdown the playing thread, but don't wait forever
|
|
self.SetKeepPlayingFlag(False)
|
|
logging.info("Waiting on shutdown %d" % (self.GetThreadShutdownFlag()))
|
|
time.sleep(.5)
|
|
i = i + 1
|
|
|
|
#make certain we clean up
|
|
if self.jet is not None:
|
|
SafeJetShutdown(self.playerLock, self.jet)
|
|
self.Destroy()
|
|
|