def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
# print '\nSHUFFLED previous is', self.mon.id(self.previous_player)
self.mon.trace(self, '')
self.display_eggtimer()
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
# start timeout for the track if required
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer = self.canvas.after(
self.track_timeout * 1000, self.track_timeout_callback)
# read the show links. Track links will be added by ready_callback
# needs to be done in show loop as each track adds different links to the show links
if self.show_params['disable-controls'] == 'yes':
self.links = []
else:
reason, message, self.links = self.path.parse_links(
self.show_params['links'], self.allowed_links)
if reason == 'error':
self.mon.err(self, message + " in show")
self.end('error', message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, False)
def start_list(self):
# starts the list or any repeat having waited for trigger first.
self.state = 'playing'
# initialise track counter for the list
self.track_count = 0
# start interval timer
self.interval_timer_signal = False
if self.interval != 0:
self.interval_timer = self.canvas.after(self.interval * 1000,
self.end_interval_timer)
#get rid of previous track in order to display the empty message
if self.medialist.display_length() == 0:
if self.show_params['empty-text']:
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
Show.display_admin_message(self,
self.show_params['empty-text'])
self.wait_for_not_empty()
else:
self.stop_timers()
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
else:
self.not_empty()
def wait_for_trigger(self):
# wait for trigger sets the state to waiting so that trigger events can do a start_list.
self.state='waiting'
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ": Waiting for trigger: "+ self.show_params['trigger-start-type'])
if self.show_params['trigger-start-type'] == "input":
#close the previous track to display admin message
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
Show.display_admin_message(self,self.show_params['trigger-wait-text'])
elif self.show_params['trigger-start-type'] == "input-persist":
if self.first_list ==True:
#first time through track list so play the track without waiting to get to end.
self.start_list()
else:
#wait for trigger while displaying previous track
pass
elif self.show_params['trigger-start-type'] == "start":
# don't close the previous track to give seamless repeat of the show
self.start_list()
else:
self.mon.err(self,"Unknown trigger: "+ self.show_params['trigger-start-type'])
self.end('error',"Unknown trigger: "+ self.show_params['trigger-start-type'])
def start_load_show_loop(self, selected_track):
# uncomment the next line to write stats for every track
# Show.write_stats(self,'play a track',self.show_params,selected_track)
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child = True
else:
self.enable_child = False
# read the show links. Track links will be added by ready_callback
# needs to be done in show loop as each track adds different links to the show links
if self.show_params['disable-controls'] == 'yes':
self.links = []
else:
reason, message, self.links = self.path.parse_links(
self.show_params['links'], self.allowed_links)
if reason == 'error':
self.mon.err(self, message + " in show")
self.end('error', message + " in show")
# load the track or show
# params - track,enable_menu
enable = self.enable_child & self.enable_hint
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, enable)
def wait_for_trigger(self):
# wait for trigger sets the state to waiting so that trigger events can do a start_list.
self.state='waiting'
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ": Waiting for trigger: "+ self.show_params['trigger-start-type'])
if self.show_params['trigger-start-type'] == "input":
#close the previous track to display admin message
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
Show.display_admin_message(self,self.show_params['trigger-wait-text'])
elif self.show_params['trigger-start-type'] == "input-persist":
if self.first_list ==True:
#first time through track list so play the track without waiting to get to end.
self.start_list()
else:
#wait for trigger while displaying previous track
pass
elif self.show_params['trigger-start-type'] == "start":
# don't close the previous track to give seamless repeat of the show
self.start_list()
else:
self.mon.err(self,"Unknown trigger: "+ self.show_params['trigger-start-type'])
self.end('error',"Unknown trigger: "+ self.show_params['trigger-start-type'])
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
# print '\nSHUFFLED previous is', self.mon.id(self.previous_player)
self.mon.trace(self,'')
self.display_eggtimer()
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
# start timeout for the track if required
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer=self.canvas.after(self.track_timeout*1000,self.track_timeout_callback)
# read the show links. Track links will be added by ready_callback
# needs to be done in show loop as each track adds different links to the show links
if self.show_params['disable-controls'] == 'yes':
self.links=[]
else:
reason,message,self.links=self.path.parse_links(self.show_params['links'],self.allowed_links)
if reason == 'error':
self.mon.err(self,message + " in show")
self.end('error',message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,False)
def start_list(self):
# starts the list or any repeat having waited for trigger first.
self.state='playing'
# initialise track counter for the list
self.track_count=0
# start interval timer
self.interval_timer_signal = False
if self.interval != 0:
self.interval_timer=self.canvas.after(self.interval*1000,self.end_interval_timer)
#get rid of previous track in order to display the empty message
if self.medialist.display_length() == 0:
if self.show_params['empty-text']:
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
Show.display_admin_message(self,self.show_params['empty-text'])
self.wait_for_not_empty()
else:
self.stop_timers()
self.ending_reason='exit'
Show.base_close_or_unload(self)
else:
self.not_empty()
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child = True
else:
self.enable_child = False
# load the track or show
# params - track,enable_menu
enable = self.enable_child & self.enable_hint
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, enable)
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child=True
else:
self.enable_child=False
# load the track or show
# params - track,enable_menu
enable=self.enable_child & self.enable_hint
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,enable)
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self, '')
self.display_eggtimer()
# start the show timer when displaying the first track
if self.current_track_ref == self.first_track_ref:
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(
self.show_timeout * 1000, self.show_timeout_stop)
# start timeout for the track if required ???? differnet to radiobuttonshow
if self.continue_timeout is False:
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
# print ('KRT set track timeout timer')
self.track_timeout_timer = self.canvas.after(
self.track_timeout * 1000, self.track_timeout_callback)
# get control bindings for this show
# needs to be done for each track as track can override the show controls
# read the show links. Track links will be added by track_ready_callback
if self.show_params['disable-controls'] == 'yes':
self.links = []
else:
reason, message, self.links = self.path.parse_links(
self.show_params['links'], self.allowed_links)
if reason == 'error':
self.mon.err(self, message + " in show")
self.end('error', message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, False)
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self, "")
self.display_eggtimer()
# get control bindings for this show
# needs to be done for each track as track can override the show controls
if self.show_params["disable-controls"] == "yes":
self.controls_list = []
else:
reason, message, self.controls_list = self.controlsmanager.get_controls(self.show_params["controls"])
if reason == "error":
self.mon.err(self, message)
self.end("error", "error in controls")
return
# load the track or show
Show.base_load_track_or_show(self, selected_track, self.what_next_after_load, self.end_shower, False)
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self,'')
self.display_eggtimer()
# get control bindings for this show
# needs to be done for each track as track can override the show controls
if self.show_params['disable-controls'] == 'yes':
self.controls_list=[]
else:
reason,message,self.controls_list= self.controlsmanager.get_controls(self.show_params['controls'])
if reason=='error':
self.mon.err(self,message)
self.end('error',"error in controls")
return
# load the track or show
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,False)
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self, '')
self.display_eggtimer()
# start the show timer when displaying the first track
if self.current_track_ref == self.first_track_ref:
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout*1000 ,self.show_timeout_stop)
# start timeout for the track if required ???? differnet to radiobuttonshow
if self.continue_timeout is False:
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer=self.canvas.after(self.track_timeout*1000,self.track_timeout_callback)
# get control bindings for this show
# needs to be done for each track as track can override the show controls
# read the show links. Track links will be added by track_ready_callback
if self.show_params['disable-controls'] == 'yes':
self.links=[]
else:
reason,message,self.links=self.path.parse_links(self.show_params['links'],self.allowed_links)
if reason == 'error':
self.mon.err(self,message + " in show")
self.end('error',message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,False)
def start_load_show_loop(self, selected_track):
# uncomment the next line to write stats for every track
# Show.write_stats(self,'play a track',self.show_params,selected_track)
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child = True
else:
self.enable_child = False
# load the track or show
# params - track,enable_menu
enable = self.enable_child & self.enable_hint
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, enable)
def start_list(self):
# starts the list or any repeat having waited for trigger first.
self.state='playing'
# initialise track counter for the list
self.track_count=0
# start interval timer
self.interval_timer_signal = False
if self.interval != 0:
self.interval_timer=self.canvas.after(self.interval*1000,self.end_interval_timer)
#get rid of previous track in order to display the empty message
if self.medialist.display_length() == 0:
#Get current mac address
str = open('/sys/class/net/eth0/address').read()
#Remove : from the mac address for ease of reading
address = re.sub(':', '', str[0:17])
#Get system ip address
ipAddr = check_output(["hostname", "-I"]).rstrip()
#Check for ip
if ipAddr:
iptext = "Monitor IP Address: " + ipAddr + "\n"
else:
iptext = ""
#Check for internet connection
if self.internet_on():
addtext = "Monitor is connected to the internet"
else:
addtext = "Monitor not connected to a network with a internet connection\nPlease connect the monitor to a network with an internet connection\nUse a network cabel or wifi dongle to do so"
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
#Show.display_admin_message(self,self.show_params['empty-text'])
Show.display_admin_message(self,'Monitor has nothing to play\nMonitor Code: ' + address + '\nAdd this monitor to your account to get started\n' + iptext + addtext)
self.wait_for_not_empty()
else:
self.not_empty()
def start_load_show_loop(self,selected_track):
# uncomment the next line to write stats for every track
# Show.write_stats(self,'play a track',self.show_params,selected_track)
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child=True
else:
self.enable_child=False
# load the track or show
# params - track,enable_menu
enable=self.enable_child & self.enable_hint
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,enable)
def what_next_after_showing(self):
self.mon.trace(self,self.pretty_what_next_after_showing_state())
self.track_count+=1
# set false when child rack is to be played
self.enable_hint=True
# first of all deal with conditions that do not require the next track to be shown
# some of the conditions can happen at any time, others only when a track is closed or at pause_at_end
# need to terminate
if self.terminate_signal is True:
self.terminate_signal=False
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.error_signal== True or self.req_next=='error':
self.error_signal=False
self.req_next=''
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# used for exiting show from other shows, time of day, external etc.
elif self.exit_signal is True:
self.exit_signal=False
self.stop_timers()
self.ending_reason='exit'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user wants to stop the show
elif self.user_stop_signal is True:
self.user_stop_signal=False
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# interval > 0. If last track has finished we are waiting for interval timer before ending the list
# note: if medialist finishes after interval is up then this route is used to start trigger.
elif self.waiting_for_interval is True:
# interval_timer_signal set by alarm clock started in start_list
if self.interval_timer_signal is True:
self.interval_timer_signal=False
self.waiting_for_interval=False
# print 'RECEIVED INTERVAL TIMER SIGNAL'
if self.show_params['repeat']=='repeat':
self.wait_for_trigger()
else:
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
self.poll_for_interval_timer=self.canvas.after(1000,self.what_next_after_showing)
# has content of list been changed (replaced if it has, used for content of livelist)
# causes it to go to wait_for_trigger and start_list
#not sure why need clos_and_unload here ???????
elif self.medialist.replace_if_changed() is True:
self.ending_reason='change-medialist'
# print 'CHANGE REQ'
Show.base_close_or_unload(self)
# otherwise consider operation that might show the next track
else:
# setup default direction for next track as normally goes forward unless kicked back
self.kickback_for_next_track=False
# print 'init direction to False at begin of what_next_after showing', self.kickback_for_next_track
# end trigger from input, or track count
if self.end_trigger_signal is True or (self.track_count_limit >0 and self.track_count == self.track_count_limit):
self.end_trigger_signal=False
# repeat so test start trigger
if self.show_params['repeat'] == 'repeat':
self.stop_timers()
# print 'END TRIGGER restart'
self.wait_for_trigger()
else:
# single run so exit show
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
self.end('normal',"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user wants to play child
elif self.play_child_signal is True:
self.play_child_signal=False
index = self.medialist.index_of_track(self.child_track_ref)
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from child
child_track=self.medialist.track(index)
Show.write_stats(self,'play child',self.show_params,child_track)
self.display_eggtimer()
self.enable_hint=False
self.start_load_show_loop(child_track)
else:
self.mon.err(self,"Child not found in medialist: "+ self.child_track_ref)
self.ending_reason='error'
Show.base_close_or_unload(self)
# skip to next track on user input or after subshow
elif self.next_track_signal is True:
# print 'skip forward test' ,self.subshow_kickback_signal
if self.next_track_signal is True or self.subshow_kickback_signal is False:
self.next_track_signal=False
self.kickback_for_next_track=False
if self.medialist.at_end() is True:
# medialist_at_end can give false positive for shuffle
if self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal',"Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do next track
self.kickback_for_next_track=False
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# skip to previous track on user input or after subshow
elif self.previous_track_signal is True or self.subshow_kickback_signal is True:
# print 'skip backward test, subshow kickback is' ,self.subshow_kickback_signal
self.subshow_kickback_signal=False
self.previous_track_signal=False
self.kickback_for_next_track=True
# medialist_at_start can give false positive for shuffle
if self.medialist.at_start() is True:
# print 'AT START'
if self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat':
self.kickback_for_next_track=True
self.wait_for_trigger()
elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track=True
self.subshow_kickback_signal=True
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal',"Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do previous track
self.kickback_for_next_track=True
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# AT END OF MEDIALIST
elif self.medialist.at_end() is True:
# print 'MEDIALIST AT END'
# interval>0 and list finished so wait for the interval timer
if self.show_params['sequence'] == "ordered" and self.interval > 0 and self.interval_timer_signal==False:
self.waiting_for_interval=True
# print 'WAITING FOR INTERVAL'
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
self.poll_for_interval_timer=self.canvas.after(200,self.what_next_after_showing)
# interval=0
#elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat' and self.show_params['trigger-end-type']== 'interval' and int(self.show_params['trigger-end-param']) == 0:
#self.medialist.next(self.show_params['sequence'])
# self.start_load_show_loop(self.medialist.selected_track())
# shuffling so there is no end condition, get out of end test
elif self.show_params['sequence'] == "shuffle":
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# nothing special to do at end of list, just repeat or exit
elif self.show_params['sequence'] == "ordered":
if self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
else:
# single run
# if not at top return to parent
if self.level !=0:
self.end('normal',"End of Single Run")
else:
# at top so close the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
self.mon.err(self,"Unhandled playing event at end of list: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
self.end('error',"Unhandled playing event at end of list: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
elif self.medialist.at_end() is False:
# nothing special just do the next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# unhandled state
self.mon.err(self,"Unhandled playing event: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
self.end('error',"Unhandled playing event: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
def what_next_after_showing(self):
self.mon.trace(self, self.pretty_what_next_after_showing_state())
self.track_count += 1
# set false when child rack is to be played
self.enable_hint = True
# first of all deal with conditions that do not require the next track to be shown
# some of the conditions can happen at any time, others only when a track is closed or at pause_at_end
# need to terminate
if self.terminate_signal is True:
self.terminate_signal = False
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason = 'killed'
Show.base_close_or_unload(self)
elif self.error_signal == True or self.req_next == 'error':
self.error_signal = False
self.req_next = ''
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# used for exiting show from other shows, time of day, external etc.
elif self.exit_signal is True:
self.exit_signal = False
self.stop_timers()
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user wants to stop the show
elif self.user_stop_signal is True:
self.user_stop_signal = False
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# interval > 0. If last track has finished we are waiting for interval timer before ending the list
# note: if medialist finishes after interval is up then this route is used to start trigger.
elif self.waiting_for_interval is True:
# interval_timer_signal set by alarm clock started in start_list
if self.interval_timer_signal is True:
self.interval_timer_signal = False
self.waiting_for_interval = False
# print 'RECEIVED INTERVAL TIMER SIGNAL'
if self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
else:
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
self.poll_for_interval_timer = self.canvas.after(
1000, self.what_next_after_showing)
# has content of list been changed (replaced if it has, used for content of livelist)
# causes it to go to wait_for_trigger and start_list
#not sure why need clos_and_unload here ???????
elif self.medialist.replace_if_changed() is True:
self.ending_reason = 'change-medialist'
# print 'CHANGE REQ'
Show.base_close_or_unload(self)
# otherwise consider operation that might show the next track
else:
# setup default direction for next track as normally goes forward unless kicked back
self.kickback_for_next_track = False
# print 'init direction to False at begin of what_next_after showing', self.kickback_for_next_track
# end trigger from input, or track count
if self.end_trigger_signal is True or (self.track_count_limit > 0
and self.track_count
== self.track_count_limit):
self.end_trigger_signal = False
# repeat so test start trigger
if self.show_params['repeat'] == 'repeat':
self.stop_timers()
# print 'END TRIGGER restart'
self.wait_for_trigger()
else:
# single run so exit show
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
self.end('normal',
"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user wants to play child
elif self.play_child_signal is True:
self.play_child_signal = False
index = self.medialist.index_of_track(self.child_track_ref)
if index >= 0:
# don't use select the track as need to preserve mediashow sequence for returning from child
child_track = self.medialist.track(index)
Show.write_stats(self, 'play child', self.show_params,
child_track)
self.display_eggtimer()
self.enable_hint = False
self.start_load_show_loop(child_track)
else:
self.mon.err(
self, "Child not found in medialist: " +
self.child_track_ref)
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# skip to next track on user input or after subshow
elif self.next_track_signal is True:
# print 'skip forward test' ,self.subshow_kickback_signal
if self.next_track_signal is True or self.subshow_kickback_signal is False:
self.next_track_signal = False
self.kickback_for_next_track = False
if self.medialist.at_end() is True:
# medialist_at_end can give false positive for shuffle
if self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'repeat':
self.wait_for_trigger()
elif self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal', "Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do next track
self.kickback_for_next_track = False
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
# skip to previous track on user input or after subshow
elif self.previous_track_signal is True or self.subshow_kickback_signal is True:
# print 'skip backward test, subshow kickback is' ,self.subshow_kickback_signal
self.subshow_kickback_signal = False
self.previous_track_signal = False
self.kickback_for_next_track = True
# medialist_at_start can give false positive for shuffle
if self.medialist.at_start() is True:
# print 'AT START'
if self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'repeat':
self.kickback_for_next_track = True
self.wait_for_trigger()
elif self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = True
self.subshow_kickback_signal = True
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal', "Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do previous track
self.kickback_for_next_track = True
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# AT END OF MEDIALIST
elif self.medialist.at_end() is True:
# print 'MEDIALIST AT END'
# interval>0 and list finished so wait for the interval timer
if self.show_params[
'sequence'] == "ordered" and self.interval > 0 and self.interval_timer_signal == False:
self.waiting_for_interval = True
# print 'WAITING FOR INTERVAL'
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
self.poll_for_interval_timer = self.canvas.after(
200, self.what_next_after_showing)
# interval=0
#elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat' and self.show_params['trigger-end-type']== 'interval' and int(self.show_params['trigger-end-param']) == 0:
#self.medialist.next(self.show_params['sequence'])
# self.start_load_show_loop(self.medialist.selected_track())
# shuffling so there is no end condition, get out of end test
elif self.show_params['sequence'] == "shuffle":
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# nothing special to do at end of list, just repeat or exit
elif self.show_params['sequence'] == "ordered":
if self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
else:
# single run
# if not at top return to parent
if self.level != 0:
self.end('normal', "End of Single Run")
else:
# at top so close the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
self.mon.err(
self, "Unhandled playing event at end of list: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
self.end(
'error', "Unhandled playing event at end of list: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
elif self.medialist.at_end() is False:
# nothing special just do the next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# unhandled state
self.mon.err(
self, "Unhandled playing event: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
self.end(
'error', "Unhandled playing event: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
def what_next_after_showing(self):
# print 'WHAT NEXT'
self.mon.trace(self,self.pretty_what_next_after_showing_state())
self.track_count+=1
# set false when child rack is to be played
self.enable_hint=True
# first of all deal with conditions that do not require the next track to be shown
# some of the conditions can happen at any time, others only when a track is closed or at pause_at_end
# need to terminate
if self.terminate_signal is True:
self.terminate_signal=False
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.error_signal== True or self.req_next=='error':
self.error_signal=False
self.req_next=''
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# used for exiting show from other shows, time of day, external etc.
elif self.exit_signal is True:
self.exit_signal=False
self.stop_timers()
self.ending_reason='exit'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user wants to stop the show
elif self.user_stop_signal is True:
self.user_stop_signal=False
# print 'user stop'
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# interval > 0. If last track has finished we are waiting for interval timer before ending the list
# note: if medialist finishes after interval is up then this route is used to start trigger.
elif self.waiting_for_interval is True:
# interval_timer_signal set by alarm clock started in start_list
if self.interval_timer_signal is True:
self.interval_timer_signal=False
self.waiting_for_interval=False
# print 'RECEIVED INTERVAL TIMER SIGNAL'
if self.show_params['repeat']=='repeat':
self.wait_for_trigger()
else:
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
self.poll_for_interval_timer=self.canvas.after(1000,self.what_next_after_showing)
else:
self.medialist.create_new_livelist()
escapetrack_required=self.escapetrack_required
self.escapetrack_required=False
# print escapetrack_required,self.medialist.new_length()
if escapetrack_required is True and self.medialist.new_length() == 0:
# print 'use escape track'
index = self.medialist.index_of_track(self.show_params['escape-track-ref'])
self.mon.log(self,'Starting Escape Track: '+ self.show_params['escape-track-ref'])
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from esacpe track
escape_track=self.medialist.track(index)
Show.write_stats(self,'play escape track',self.show_params,escape_track)
self.display_eggtimer()
# use new empty livelist so if changed works OK when return from empty track
self.medialist.use_new_livelist()
self.start_load_show_loop(escape_track)
else:
self.mon.err(self,"Escape Track empty")
self.end('error',"Escape Track empty")
# print 'FOR IF CHANGED',self.first_list,self.medialist.length(),self.medialist.new_length(),self.medialist.livelist_changed()
elif self.first_list is True or self.medialist.livelist_changed() is True or (self.medialist.length() == 0 and self.medialist.new_length() == 0):
if self.first_list is False:
# do show control
if self.medialist.length() == 0 and self.medialist.new_length() != 0:
# print 'show control empty to not empty'
# do show control when goes from not empty to empty only
self.show_control(self.show_params['show-control-not-empty'])
elif self.medialist.length() != 0 and self.medialist.new_length() == 0:
# print 'show control not empty to empty'
# do show control when goes from empty to not empty only
self.show_control(self.show_params['show-control-empty'])
self.first_list=False
if self.medialist.new_length()==0 and self.show_params['repeat']=='repeat':
# start empty track/show
index = self.medialist.index_of_track(self.show_params['empty-track-ref'])
self.mon.log(self,'Starting Empty Track: '+ self.show_params['empty-track-ref'])
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from empty track/show
empty_track=self.medialist.track(index)
# print 'play empty track', empty_track['title'],empty_track['type']
Show.write_stats(self,'play empty track',self.show_params,empty_track)
if empty_track['type'] =='show':
self.escapetrack_required=True
self.display_eggtimer()
# use new empty livelist so if changed works OK when return from empty track
self.medialist.use_new_livelist()
self.start_load_show_loop(empty_track)
else:
self.mon.err(self,"List Empty Track not specified")
self.end('error',"List Empty Track not specified")
elif self.medialist.new_length()==0 and self.show_params['repeat']=='single-run':
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
self.end('normal',"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
#changed but new is not zero
self.medialist.use_new_livelist()
# print 'livelist changed and not empty'
self.start_list()
# otherwise consider operation that might show the next track
else:
# print 'ELSE',self.medialist.at_end()
# report error if medilaist is empty (liveshow will not get this far
if self.medialist.length()==0:
self.mon.err(self,"Medialist empty")
self.end('error',"Medialist empty")
# setup default direction for next track as normally goes forward unless kicked back
self.kickback_for_next_track=False
# print 'init direction to False at begin of what_next_after showing', self.kickback_for_next_track
# end trigger from input, or track count
if self.end_trigger_signal is True or (self.track_count_limit >0 and self.track_count == self.track_count_limit):
self.end_trigger_signal=False
# repeat so test start trigger
if self.show_params['repeat'] == 'repeat':
self.stop_timers()
# print 'END TRIGGER restart'
self.wait_for_trigger()
else:
# single run so exit show
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
# print 'single run exit subshow'
self.end('normal',"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
# print 'ENDING'
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user wants to play child
elif self.play_child_signal is True:
self.play_child_signal=False
index = self.medialist.index_of_track(self.child_track_ref)
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from child
child_track=self.medialist.track(index)
Show.write_stats(self,'play child',self.show_params,child_track)
self.display_eggtimer()
self.enable_hint=False
self.start_load_show_loop(child_track)
else:
self.mon.err(self,"Child not found in medialist: "+ self.child_track_ref)
self.ending_reason='error'
Show.base_close_or_unload(self)
# skip to next track on user input or after subshow
elif self.next_track_signal is True:
# print 'skip forward test' ,self.subshow_kickback_signal
if self.next_track_signal is True or self.subshow_kickback_signal is False:
self.next_track_signal=False
self.kickback_for_next_track=False
if self.medialist.at_end() is True:
# medialist_at_end can give false positive for shuffle
if self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal',"Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do next track
self.kickback_for_next_track=False
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# skip to previous track on user input or after subshow
elif self.previous_track_signal is True or self.subshow_kickback_signal is True:
# print 'skip backward test, subshow kickback is' ,self.subshow_kickback_signal
self.subshow_kickback_signal=False
self.previous_track_signal=False
self.kickback_for_next_track=True
# medialist_at_start can give false positive for shuffle
if self.medialist.at_start() is True:
# print 'AT START'
if self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat':
self.kickback_for_next_track=True
self.wait_for_trigger()
elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track=True
self.subshow_kickback_signal=True
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal',"Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do previous track
self.kickback_for_next_track=True
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# AT END OF MEDIALIST
elif self.medialist.at_end() is True:
# print 'MEDIALIST AT END'
# interval>0 and list finished so wait for the interval timer
if self.show_params['sequence'] == "ordered" and self.interval > 0 and self.interval_timer_signal==False:
self.waiting_for_interval=True
# print 'WAITING FOR INTERVAL'
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
self.poll_for_interval_timer=self.canvas.after(200,self.what_next_after_showing)
# interval=0
#elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat' and self.show_params['trigger-end-type']== 'interval' and int(self.show_params['trigger-end-param']) == 0:
#self.medialist.next(self.show_params['sequence'])
# self.start_load_show_loop(self.medialist.selected_track())
# shuffling so there is no end condition, get out of end test
elif self.show_params['sequence'] == "shuffle":
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# nothing special to do at end of list, just repeat or exit
elif self.show_params['sequence'] == "ordered":
if self.show_params['repeat'] == 'repeat':
# print 'repeating at end of list'
self.wait_for_trigger()
else:
# single run
# if not at top return to parent
if self.level !=0:
self.end('normal',"End of Single Run")
else:
# at top so close the show
# print 'closing show'
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
self.mon.err(self,"Unhandled playing event at end of list: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
self.end('error',"Unhandled playing event at end of list: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
elif self.medialist.at_end() is False:
# nothing special just do the next track
# print 'nothing special'
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# unhandled state
self.mon.err(self,"Unhandled playing event: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
self.end('error',"Unhandled playing event: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
def what_next_after_showing(self):
#inhibit for trigger next
self.playing_track = False
# print 'WHAT NEXT'
self.mon.trace(self, self.pretty_what_next_after_showing_state())
self.track_count += 1
# set false when child rack is to be played
self.enable_hint = True
# first of all deal with conditions that do not require the next track to be shown
# some of the conditions can happen at any time, others only when a track is closed or at pause_at_end
# need to terminate
if self.terminate_signal is True:
self.terminate_signal = False
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason = 'killed'
Show.base_close_or_unload(self)
elif self.error_signal == True or self.req_next == 'error':
self.error_signal = False
self.req_next = ''
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# used for exiting show from other shows, time of day, external etc.
elif self.exit_signal is True:
self.exit_signal = False
self.stop_timers()
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user wants to stop the show
elif self.user_stop_signal is True:
self.user_stop_signal = False
# print 'user stop'
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# interval > 0. If last track has finished we are waiting for interval timer before ending the list
# note: if medialist finishes after interval is up then this route is used to start trigger.
elif self.waiting_for_interval is True:
# interval_timer_signal set by alarm clock started in start_list
if self.interval_timer_signal is True:
self.interval_timer_signal = False
self.waiting_for_interval = False
# print 'RECEIVED INTERVAL TIMER SIGNAL'
if self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
else:
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
self.poll_for_interval_timer = self.canvas.after(
1000, self.what_next_after_showing)
else:
self.medialist.create_new_livelist()
escapetrack_required = self.escapetrack_required
self.escapetrack_required = False
# print escapetrack_required,self.medialist.new_length()
if escapetrack_required is True and self.medialist.new_length(
) == 0:
# print 'use escape track'
index = self.medialist.index_of_track(
self.show_params['escape-track-ref'])
self.mon.log(
self, 'Starting Escape Track: ' +
self.show_params['escape-track-ref'])
if index >= 0:
# don't use select the track as need to preserve mediashow sequence for returning from esacpe track
escape_track = self.medialist.track(index)
Show.write_stats(self, 'play escape track',
self.show_params, escape_track)
self.display_eggtimer()
# use new empty livelist so if changed works OK when return from empty track
self.medialist.use_new_livelist()
self.start_load_show_loop(escape_track)
else:
self.mon.err(self, "Escape Track empty")
self.end('error', "Escape Track empty")
# print 'FOR IF CHANGED',self.first_list,self.medialist.length(),self.medialist.new_length(),self.medialist.livelist_changed()
elif self.first_list is True or self.medialist.livelist_changed(
) is True or (self.medialist.length() == 0
and self.medialist.new_length() == 0):
if self.first_list is False:
# do show control
if self.medialist.length(
) == 0 and self.medialist.new_length() != 0:
# print 'show control empty to not empty'
# do show control when goes from not empty to empty only
self.show_control(
self.show_params['show-control-not-empty'])
elif self.medialist.length(
) != 0 and self.medialist.new_length() == 0:
# print 'show control not empty to empty'
# do show control when goes from empty to not empty only
self.show_control(
self.show_params['show-control-empty'])
self.first_list = False
if self.medialist.new_length(
) == 0 and self.show_params['repeat'] == 'repeat':
# start empty track/show
index = self.medialist.index_of_track(
self.show_params['empty-track-ref'])
self.mon.log(
self, 'Starting Empty Track: ' +
self.show_params['empty-track-ref'])
if index >= 0:
# don't use select the track as need to preserve mediashow sequence for returning from empty track/show
empty_track = self.medialist.track(index)
# print 'play empty track', empty_track['title'],empty_track['type']
Show.write_stats(self, 'play empty track',
self.show_params, empty_track)
if empty_track['type'] == 'show':
self.escapetrack_required = True
self.display_eggtimer()
# use new empty livelist so if changed works OK when return from empty track
self.medialist.use_new_livelist()
self.start_load_show_loop(empty_track)
else:
self.mon.err(self, "List Empty Track not specified")
self.end('error', "List Empty Track not specified")
elif self.medialist.new_length(
) == 0 and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
self.end('normal',
"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
#changed but new is not zero
self.medialist.use_new_livelist()
# print 'livelist changed and not empty'
self.start_list()
# otherwise consider operation that might show the next track
else:
# print 'ELSE',self.medialist.at_end()
# report error if medilaist is empty (liveshow will not get this far
if self.medialist.length() == 0:
self.mon.err(self, "Medialist empty")
self.end('error', "Medialist empty")
# setup default direction for next track as normally goes forward unless kicked back
self.kickback_for_next_track = False
# print 'init direction to False at begin of what_next_after showing', self.kickback_for_next_track
# end trigger from input, or track count
if self.end_trigger_signal is True or (
self.track_count_limit > 0
and self.track_count == self.track_count_limit):
self.end_trigger_signal = False
# repeat so test start trigger
if self.show_params['repeat'] == 'repeat':
self.stop_timers()
# print 'END TRIGGER restart'
self.wait_for_trigger()
else:
# single run so exit show
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
# print 'single run exit subshow'
self.end(
'normal',
"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
# print 'ENDING'
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user wants to play child
elif self.play_child_signal is True:
self.play_child_signal = False
index = self.medialist.index_of_track(self.child_track_ref)
if index >= 0:
# don't use select the track as need to preserve mediashow sequence for returning from child
child_track = self.medialist.track(index)
Show.write_stats(self, 'play child', self.show_params,
child_track)
self.display_eggtimer()
self.enable_hint = False
self.start_load_show_loop(child_track)
else:
self.mon.err(
self, "Child not found in medialist: " +
self.child_track_ref)
self.ending_reason = 'error'
Show.base_close_or_unload(self)
elif self.repeat_track_signal is True:
self.repeat_track_signal = False
self.start_load_show_loop(self.medialist.selected_track())
# skip to next track on user input or after subshow
elif self.next_track_signal is True:
# print 'skip forward test' ,self.subshow_kickback_signal
if self.next_track_signal is True or self.subshow_kickback_signal is False:
self.next_track_signal = False
self.kickback_for_next_track = False
if self.medialist.at_end() is True:
# medialist_at_end can give false positive for shuffle
if self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'repeat':
self.wait_for_trigger()
elif self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal', "Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do next track
self.kickback_for_next_track = False
self.medialist.next(
self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
# skip to previous track on user input or after subshow
elif self.previous_track_signal is True or self.subshow_kickback_signal is True:
# print 'skip backward test, subshow kickback is' ,self.subshow_kickback_signal
self.subshow_kickback_signal = False
self.previous_track_signal = False
self.kickback_for_next_track = True
# medialist_at_start can give false positive for shuffle
if self.medialist.at_start() is True:
# print 'AT START'
if self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'repeat':
self.kickback_for_next_track = True
self.wait_for_trigger()
elif self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = True
self.subshow_kickback_signal = True
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal', "Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do previous track
self.kickback_for_next_track = True
self.medialist.previous(
self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
# AT END OF MEDIALIST
elif self.medialist.at_end() is True:
# print 'MEDIALIST AT END'
# interval>0 and list finished so wait for the interval timer
if self.show_params[
'sequence'] == "ordered" and self.interval > 0 and self.interval_timer_signal == False:
self.waiting_for_interval = True
# print 'WAITING FOR INTERVAL'
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
self.poll_for_interval_timer = self.canvas.after(
200, self.what_next_after_showing)
# interval=0
#elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat' and self.show_params['trigger-end-type']== 'interval' and int(self.show_params['trigger-end-param']) == 0:
#self.medialist.next(self.show_params['sequence'])
# self.start_load_show_loop(self.medialist.selected_track())
# shuffling so there is no end condition, get out of end test
elif self.show_params['sequence'] == "shuffle":
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
# nothing special to do at end of list, just repeat or exit
elif self.show_params['sequence'] == "ordered":
if self.show_params['repeat'] == 'repeat':
# print 'repeating at end of list'
self.wait_for_trigger()
else:
# single run
# if not at top return to parent
if self.level != 0:
self.end('normal', "End of Single Run")
else:
# at top so close the show
# print 'closing show'
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
self.mon.err(
self, "Unhandled playing event at end of list: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
self.end(
'error',
"Unhandled playing event at end of list: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
elif self.medialist.at_end() is False:
# nothing special just do the next track
# print 'nothing special'
if self.wait_for_next_trigger is False:
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
#close the previous track to display admin message
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
Show.display_admin_message(
self, self.show_params['trigger-wait-text'])
else:
# unhandled state
self.mon.err(
self, "Unhandled playing event: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
self.end(
'error', "Unhandled playing event: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
