class MenuShow(Show):
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(
self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback
)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
self.controlsmanager = ControlsManager()
# init variables
self.show_timeout_timer = None
self.track_timeout_timer = None
self.next_track_signal = False
self.next_track = None
self.menu_index = 0
self.menu_showing = True
self.req_next = ""
def play(self, end_callback, show_ready_callback, parent_kickback_signal, level, controls_list):
""" displays the menu
end_callback - function to be called when the menu exits
show_ready_callback - callback when menu is ready to display (not used)
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal - not used other than it being passed to a show
"""
# need to instantiate the medialist here as not using gapshow
self.medialist = MediaList("ordered")
Show.base_play(self, end_callback, show_ready_callback, parent_kickback_signal, level, controls_list)
self.mon.trace(self, self.show_params["show-ref"])
# parse the show and track timeouts
reason, message, self.show_timeout = Show.calculate_duration(self, self.show_params["show-timeout"])
if reason == "error":
self.mon.err(self, "Show Timeout has bad time: " + self.show_params["show-timeout"])
self.end("error", "show timeout, bad time")
reason, message, self.track_timeout = Show.calculate_duration(self, self.show_params["track-timeout"])
if reason == "error":
self.mon.err(self, "Track Timeout has bad time: " + self.show_params["track-timeout"])
self.end("error", "track timeout, bad time")
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
# and display the menu
self.do_menu_track()
# ********************
# respond to inputs.
# ********************
# exit received from another concurrent show
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# terminate Pi Presents
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
def handle_input_event(self, symbol):
Show.base_handle_input_event(self, symbol)
def handle_input_event_this_show(self, symbol):
# menushow has only internal operation
operation = self.base_lookup_control(symbol, self.controls_list)
self.do_operation(operation)
def do_operation(self, operation):
# service the standard inputs for this show
self.mon.trace(self, operation)
if operation == "exit":
self.exit()
elif operation == "stop":
self.stop_timers()
if self.current_player is not None:
if self.menu_showing is True and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal = True
self.current_player.input_pressed("stop")
elif operation in ("up", "down"):
# stop show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
# and start it again
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(self.show_timeout * 1000, self.show_timeout_stop)
if operation == "up":
self.previous()
else:
self.next()
elif operation == "play":
self.next_track_signal = True
self.next_track = self.medialist.selected_track()
self.current_player.stop()
# cancel show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
# stop current track (the menuplayer) if running or just start the next track
if self.current_player is not None:
self.current_player.input_pressed("stop")
else:
self.what_next_after_showing()
elif operation in ("no-command", "null"):
return
elif operation == "pause":
if self.current_player is not None:
self.current_player.input_pressed(operation)
elif operation[0:4] == "omx-" or operation[0:6] == "mplay-" or operation[0:5] == "uzbl-":
if self.current_player is not None:
self.current_player.input_pressed(operation)
def next(self):
# remove highlight
if self.current_player.__class__.__name__ == "MenuPlayer":
self.current_player.highlight_menu_entry(self.menu_index, False)
self.medialist.next("ordered")
if self.menu_index == self.menu_length - 1:
self.menu_index = 0
else:
self.menu_index += 1
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index, True)
def previous(self):
# remove highlight
if self.current_player.__class__.__name__ == "MenuPlayer":
self.current_player.highlight_menu_entry(self.menu_index, False)
if self.menu_index == 0:
self.menu_index = self.menu_length - 1
else:
self.menu_index -= 1
self.medialist.previous("ordered")
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index, True)
# *********************
# Sequencing
# *********************
def track_timeout_callback(self):
self.do_operation("stop")
def do_menu_track(self):
self.menu_showing = True
self.mon.trace(self, "")
# start show timeout alarm if required
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(self.show_timeout * 1000, self.show_timeout_stop)
# init the index used to hiighlight the selected menu entry by menuplayer
self.menu_index = 0
index = self.medialist.index_of_track(self.show_params["menu-track-ref"])
if index == -1:
self.mon.err(self, "'menu-track' not in medialist: " + self.show_params["menu-track-ref"])
self.end("error", "menu-track not in medialist: ")
return
# make the medialist available to the menuplayer for cursor scrolling
self.show_params["medialist_obj"] = self.medialist
# load the menu track
self.start_load_show_loop(self.medialist.track(index))
# *********************
# Playing show or track loop
# *********************
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)
# track has loaded (menu or otherwise) so show it.
def what_next_after_load(self, status, message):
# get the calculated length of the menu for the loaded menu track
if self.current_player.__class__.__name__ == "MenuPlayer":
if self.medialist.display_length() == 0:
self.req_next = "error"
self.what_next_after_showing()
return
self.medialist.start()
self.menu_index = 0
self.menu_length = self.current_player.menu_length
self.current_player.highlight_menu_entry(self.menu_index, True)
self.mon.trace(self, " - load complete with status: " + status + " message: " + message)
if self.current_player.play_state == "load-failed":
self.req_next = "error"
self.what_next_after_showing()
else:
if (
self.show_timeout_signal is True
or self.terminate_signal is True
or self.exit_signal is True
or self.user_stop_signal is True
):
self.what_next_after_showing()
else:
self.mon.trace(self, "")
self.current_player.show(self.track_ready_callback, self.finished_showing, self.closed_after_showing)
def finished_showing(self, reason, message):
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self, "")
self.mon.log(self, "pause at end of showing track with reason: " + reason + " and message: " + message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == "show-failed":
self.req_next = "error"
else:
self.req_next = "finished-player"
self.what_next_after_showing()
def closed_after_showing(self, reason, message):
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self, "")
self.mon.log(self, "Closed after showing track with reason: " + reason + " and message: " + message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == "show-failed":
self.req_next = "error"
else:
self.req_next = "closed-player"
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self, show_id, reason, message):
self.mon.log(
self,
self.show_params["show-ref"]
+ " "
+ str(self.show_id)
+ ": Returned from shower with "
+ reason
+ " "
+ message,
)
self.sr.hide_click_areas(self.controls_list)
self.req_next = reason
Show.base_end_shower(self)
self.what_next_after_showing()
# at the end of a track check for terminations else re-display the menu
def what_next_after_showing(self):
self.mon.trace(self, "")
# cancel track timeout timer
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
# need to terminate?
if self.terminate_signal is True:
self.terminate_signal = False
# set what to do when closed or unloaded
self.ending_reason = "killed"
Show.base_close_or_unload(self)
elif self.req_next == "error":
self.req_next = ""
# set what to do after closed or unloaded
self.ending_reason = "error"
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
# set what to do when closed or unloaded
self.ending_reason = "show-timeout"
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal = False
self.ending_reason = "exit"
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal = False
self.ending_reason = "user-stop"
Show.base_close_or_unload(self)
elif self.next_track_signal is True:
self.next_track_signal = False
self.menu_showing = False
# start timeout for the track if required
if self.track_timeout != 0:
self.track_timeout_timer = self.canvas.after(self.track_timeout * 1000, self.track_timeout_callback)
self.start_load_show_loop(self.next_track)
else:
# no stopping the show required so re-display the menu
self.do_menu_track()
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self, enable_show_background):
self.delete_eggtimer()
if self.show_params["disable-controls"] != "yes":
# merge controls from the track
controls_text = self.current_player.get_links()
reason, message, track_controls = self.controlsmanager.parse_controls(controls_text)
if reason == "error":
self.mon.err(self, message + " in track: " + self.current_player.track_params["track-ref"])
self.req_next = "error"
self.what_next_after_showing()
self.controlsmanager.merge_controls(self.controls_list, track_controls)
self.sr.enable_click_areas(self.controls_list)
Show.base_track_ready_callback(self, enable_show_background)
# callback from begining of a subshow, provide previous shower player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# Ending the show
# *********************
def end(self, reason, message):
self.stop_timers()
Show.base_end(self, reason, message)
def stop_timers(self):
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
class RadioMediaShow(Show):
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir,
pp_home, pp_profile, command_callback):
# init the common bits
Show.base__init__(self, show_id, show_params, root, canvas, showlist,
pp_dir, pp_home, pp_profile, command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
# create an instance of PathManager - only used to parse the links.
self.path = PathManager()
self.allowed_links = ('play', 'pause', 'exit', 'return', 'null',
'no-command', 'stop')
# init variables
self.links = []
self.track_timeout_timer = None
self.show_timeout_timer = None
self.next_track_signal = False
self.current_track_ref = ''
self.req_next = ''
self.controlsmanager = ControlsManager()
# Init variables special to this show
self.poll_for_interval_timer = None
self.interval_timer_signal = False
self.waiting_for_interval = False
self.interval_timer = None
self.duration_timer = None
self.end_trigger_signal = False
self.next_track_signal = False
self.previous_track_signal = False
self.play_child_signal = False
self.error_signal = False
self.show_timeout_signal = False
self.req_next = 'nil'
self.state = 'closed'
self.count = 0
self.interval = 0
self.duration = 0
self.controls_list = []
self.enable_hint = True
# def play(self,end_callback,show_ready_callback, direction_command,level,controls_list):
#
# # use the appropriate medialist
# self.medialist=MediaList(self.show_params['sequence'])
#
# GapShow.play(self,end_callback,show_ready_callback, direction_command,level,controls_list)
def play(self, end_callback, show_ready_callback, parent_kickback_signal,
level, controls_list):
# use the appropriate medialist
self.medialist = MediaList(self.show_params['sequence'])
self.mon.newline(3)
self.mon.trace(self, self.show_params['show-ref'])
Show.base_play(self, end_callback, show_ready_callback,
parent_kickback_signal, level, controls_list)
# unpack show parameters
reason, message, self.show_timeout = Show.calculate_duration(
self, self.show_params['show-timeout'])
if reason == 'error':
self.mon.err(
self, 'ShowTimeout has bad time: ' +
self.show_params['show-timeout'])
self.end(
'error', 'ShowTimeout has bad time: ' +
self.show_params['show-timeout'])
self.track_count_limit = int(self.show_params['track-count-limit'])
reason, message, self.interval = Show.calculate_duration(
self, self.show_params['interval'])
if reason == 'error':
self.mon.err(
self, 'Interval has bad time: ' + self.show_params['interval'])
self.end('error',
'Interval has bad time: ' + self.show_params['interval'])
# delete eggtimer started by the parent
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.start_show()
# respond to inputs
def handle_input_event(self, symbol):
Show.base_handle_input_event(self, symbol)
#self.handle_input_event_this_show(symbol)
def handle_input_event_this_show(self, symbol):
# for radiobuttonshow the symbolic names are links to play tracks, also a limited number of in-track operations
# find the first entry in links that matches the symbol and execute its operation
#print 'radiomediashow ', symbol
found, link_op, link_arg = self.path.find_link(symbol, self.links)
#print 'input event', symbol, link_op
if found is True:
if link_op == 'play':
#print 'playing ' + link_arg
self.do_play(link_arg)
elif link_op == 'exit':
#exit the show
self.exit()
elif link_op == 'stop':
self.stop_timers()
if self.current_player is not None:
if self.current_track_ref == self.first_track_ref and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal = True
self.current_player.input_pressed('stop')
elif link_op == 'return':
# return to the first track
if self.current_track_ref != self.first_track_ref:
self.do_play(self.first_track_ref)
# in-track operations
elif link_op == 'pause':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
elif link_op in ('no-command', 'null'):
return
elif link_op[0:4] == 'omx-' or link_op[0:6] == 'mplay-' or link_op[
0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
else:
self.mon.err(self, "unknown link command: " + link_op)
self.end('error', "unknown link command: " + link_op)
def do_play(self, track_ref):
#print 'do_play ' + track_ref
# if track_ref != self.current_track_ref:
# cancel the show timeout when playing another track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
# print '\n NEED NEXT TRACK'
#self.next_track_signal=True
self.next_track_op = 'play'
self.next_track_arg = track_ref
self.play_child_signal = True
if self.shower is not None:
#print 'current_shower not none so stopping',self.mon.id(self.current_shower)
self.shower.do_operation('stop')
elif self.current_player is not None:
#print 'current_player not none so stopping',self.mon.id(self.current_player), ' for' ,track_ref
self.current_player.input_pressed('stop')
else:
return
# ***************************
# Show sequencing
# ***************************
def start_show(self):
# initial direction from parent show
self.kickback_for_next_track = self.parent_kickback_signal
# print '\n\ninital KICKBACK from parent', self.kickback_for_next_track
# start duration timer
if self.show_timeout != 0:
# print 'set alarm ', self.show_timeout
self.duration_timer = self.canvas.after(self.show_timeout * 1000,
self.show_timeout_stop)
self.first_list = True
# and start the first list of the show
self.wait_for_trigger()
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.first_list = False
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_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:
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.not_empty()
def wait_for_not_empty(self):
if self.medialist.display_length() == 0:
# list is empty retry after 5 secs
self.canvas.after(5000, self.wait_for_not_empty)
else:
Show.delete_admin_message(self)
self.not_empty()
def not_empty(self):
#get first or last track depending on direction
# print 'use direction for start or end of list', self.kickback_for_next_track
if self.kickback_for_next_track is True:
self.medialist.finish()
else:
self.medialist.start()
self.start_load_show_loop(self.medialist.selected_track())
# ***************************
# Track load/show loop
# ***************************
# track playing loop starts here
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)
# track has loaded so show it.
def what_next_after_load(self, status, message):
self.mon.log(
self, 'Show Id ' + str(self.show_id) +
' load complete with status: ' + status + ' message: ' + message)
if self.current_player.play_state == 'load-failed':
self.error_signal = True
self.what_next_after_showing()
else:
if self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self, ' - showing track')
self.current_player.show(self.track_ready_callback,
self.finished_showing,
self.closed_after_showing)
def finished_showing(self, reason, message):
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.error_signal = True
else:
self.req_next = 'finished-player'
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self, ' - pause at end ')
self.mon.log(
self, "pause at end of showing track with reason: " + reason +
' and message: ' + message)
self.what_next_after_showing()
def closed_after_showing(self, reason, message):
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.error_signal = True
else:
self.req_next = 'closed-player'
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self, ' - closed')
self.mon.log(
self, "Closed after showing track with reason: " + reason +
' and message: ' + message)
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self, show_id, reason, message):
self.mon.log(
self, self.show_params['show-ref'] + ' ' + str(self.show_id) +
': Returned from shower with ' + reason + ' ' + message)
self.sr.hide_click_areas(self.controls_list)
self.req_next = reason
Show.base_end_shower(self)
self.what_next_after_showing()
def pretty_what_next_after_showing_state(self):
state = '\n* terminate signal ' + str(self.terminate_signal)
state += '\n* error signal ' + str(self.error_signal)
state += '\n* req_next used to indicate subshow reports an error ' + self.req_next
state += '\n* exit signal ' + str(self.exit_signal)
state += '\n* show timeout signal ' + str(self.show_timeout_signal)
state += '\n* user stop signal ' + str(self.user_stop_signal)
state += '\n* previous track signal ' + str(
self.previous_track_signal)
state += '\n* next track signal ' + str(self.next_track_signal)
state += '\n* kickback from subshow ' + str(
self.subshow_kickback_signal)
return state + '\n'
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)
# play user selected track # HOOK !
self.current_track_ref = self.next_track_arg
#print 'what next - next track signal is True so load ', self.current_track_ref
index = self.medialist.index_of_track(self.current_track_ref)
if index >= 0:
# don't use select the track as not using selected_track in radiobuttonshow
# and load it
Show.write_stats(self, 'play', self.show_params,
self.medialist.track(index))
self.display_eggtimer()
self.enable_hint = False
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(
self, "next track not found in medialist: " +
self.current_track_ref)
self.end(
'error', "next track not found in medialist: " +
self.current_track_ref)
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'])
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# # called just before a track is shown to remove the previous track from the screen
# # and if necessary close it
# def track_ready_callback(self,enable_show_background):
# self.delete_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: " + message)
# return
#
# # print 'controls',reason,self.show_params['controls'],self.controls_list
# #merge controls from the track
# controls_text=self.current_player.get_links()
# reason,message,track_controls=self.controlsmanager.parse_controls(controls_text)
# if reason == 'error':
# self.mon.err(self,message + " in track: "+ self.current_player.track_params['track-ref'])
# self.error_signal=True
# self.what_next_after_showing()
# self.controlsmanager.merge_controls(self.controls_list,track_controls)
#
# # enable the click-area that are in the list of controls
# self.sr.enable_click_areas(self.controls_list)
# Show.base_track_ready_callback(self,enable_show_background)
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self, enable_show_background):
self.delete_eggtimer()
# print 'TRACK READY CALLBACK'
# print 'previous is',self.mon.id(self.previous_player), self.next_track_signal
#merge links from the track
if self.show_params['disable-controls'] == 'yes':
track_links = []
else:
reason, message, track_links = self.path.parse_links(
self.current_player.get_links(), self.allowed_links)
if reason == 'error':
self.mon.err(
self, message + " in track: " +
self.current_player.track_params['track-ref'])
self.req_next = 'error'
self.what_next_after_showing()
self.path.merge_links(self.links, track_links)
# enable the click-area that are in the list of links
self.sr.enable_click_areas(self.links)
Show.base_track_ready_callback(self, enable_show_background)
# callback from begining of a subshow, provide previous player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
def end(self, reason, message):
Show.base_end(self, reason, message)
def stop_timers(self):
# clear outstanding time of day events for this show
# self.tod.clear_times_list(id(self))
if self.poll_for_interval_timer is not None:
self.canvas.after_cancel(self.poll_for_interval_timer)
self.poll_for_interval_timer = None
if self.interval_timer is not None:
self.canvas.after_cancel(self.interval_timer)
self.interval_timer = None
if self.duration_timer is not None:
self.canvas.after_cancel(self.duration_timer)
self.duration_timer = None
class MenuShow:
""" Displays a menu with optional hint below it. User can traverse the menu and
select a track using key or button presses.
Interface:
* play - displays the menu and selects the first entry
* input_pressed, - receives user events passes them to a Player if a track is playing,
otherwise actions them with _next, _previous, _play_selected_track, _end
Optional display of eggtimer by means of Players ready_callback
Supports imageplayer, videoplayer,messagplayer,audioplayer,menushow,mediashow
Destroys itself on exit
"""
# *********************
# external interface
# ********************
def __init__(self,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile):
""" canvas - the canvas that the menu is to be written on
show - the name of the configuration dictionary section for the menu
showlist - the showlist
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory"""
self.mon=Monitor()
self.mon.on()
self.display_guidelines_command=show_params['menu-guidelines']
self.display_guidelines=self.display_guidelines_command
#instantiate arguments
self.show_params=show_params
self.root=root
self.canvas=canvas
self.showlist=showlist
self.pp_dir=pp_dir
self.pp_home=pp_home
self.pp_profile=pp_profile
# open resources
self.rr=ResourceReader()
# init variables
self.drawn = None
self.player=None
self.shower=None
self.menu_timeout_running=None
self.error=False
def play(self,show_id,end_callback,ready_callback,top=False,command='nil'):
""" displays the menu
end_callback - function to be called when the menu exits
ready_callback - callback when menu is ready to display (not used)
top is True when the show is top level (run from [start])
"""
#instantiate arguments
self.show_id=show_id
self.end_callback=end_callback
self.ready_callback=ready_callback
self.top=top
self.command=command
# check data files are available.
self.menu_file = self.pp_profile + "/" + self.show_params['medialist']
if not os.path.exists(self.menu_file):
self.mon.err(self,"Medialist file not found: "+ self.menu_file)
self.end('error',"Medialist file not found")
#create a medialist for the menu and read it.
self.medialist=MediaList()
if self.medialist.open_list(self.menu_file,self.showlist.sissue()) == False:
self.mon.err(self,"Version of medialist different to Pi Presents")
self.end('error',"Version of medialist different to Pi Presents")
#get control bindings for this show if top level
controlsmanager=ControlsManager()
if self.top==True:
self.controls_list=controlsmanager.default_controls()
# and merge in controls from profile
self.controls_list=controlsmanager.merge_show_controls(self.controls_list,self.show_params['controls'])
if self.show_params['has-background']=="yes":
background_index=self.medialist.index_of_track ('pp-menu-background')
if background_index>=0:
self.menu_img_file = self.complete_path(self.medialist.track(background_index)['location'])
if not os.path.exists(self.menu_img_file):
self.mon.err(self,"Menu background file not found: "+ self.menu_img_file)
self.end('error',"Menu background file not found")
else:
self.mon.err(self,"Menu background not found in medialist")
self.end('error',"Menu background not found")
self.end_menushow_signal= False
if self.ready_callback<>None:
self.ready_callback()
self.menu_timeout_value=int(self.show_params['timeout'])*1000
self.do_menu()
def do_menu(self):
#start timeout alarm if required
if int(self.show_params['timeout'])<>0:
self.menu_timeout_running=self.canvas.after(self.menu_timeout_value,self.timeout_menu)
if self.show_params['menu-background-colour']<>'':
self.canvas.config(bg=self.show_params['menu-background-colour'])
self.canvas.delete('pp-content')
self.canvas.update()
# display background image
if self.show_params['has-background']=="yes":
self.display_background()
self.delete_eggtimer()
self.display_new_menu()
self.canvas.tag_raise('pp-click-area')
self.canvas.update_idletasks( )
# display menu text if enabled
if self.show_params['menu-text']<> '':
self.canvas.create_text(int(self.show_params['menu-text-x']),int(self.show_params['menu-text-y']),
anchor=NW,
text=self.show_params['menu-text'],
fill=self.show_params['menu-text-colour'],
font=self.show_params['menu-text-font'],
tag='pp-content')
self.canvas.update_idletasks( )
# display instructions (hint)
hint_text=self.show_params['hint-text']
if hint_text<>'':
self.canvas.create_text(int(self.show_params['hint-x']),int(self.show_params['hint-y']),
anchor=NW,
text=hint_text,
fill=self.show_params['hint-colour'],
font=self.show_params['hint-font'],
tag='pp-content')
self.canvas.update_idletasks( )
#stop received from another concurrent show
def managed_stop(self):
if self.menu_timeout_running<>None:
self.canvas.after_cancel(self.menu_timeout_running)
self.menu_timeout_running=None
if self.shower<>None:
self.shower.managed_stop()
elif self.player<>None:
self.end_menushow_signal=True
self.player.input_pressed('stop')
else:
self.end('normal','stopped by ShowManager')
# kill or error received
def terminate(self,reason):
if self.menu_timeout_running<>None:
self.canvas.after_cancel(self.menu_timeout_running)
self.menu_timeout_running=None
if self.shower<>None:
self.shower.terminate(reason)
elif self.player<>None:
self.player.terminate(reason)
else:
self.end(reason,'Terminated no shower or player running')
# respond to user inputs.
def input_pressed(self,symbol,edge,source):
self.mon.log(self,"Show Id: "+str(self.show_id)+" received key or operation: " + symbol)
if self.show_params['disable-controls']=='yes':
return
# if at top convert symbolic name to operation otherwise lower down we have received an operation
# look through list of standard symbols to find match (symbolic-name, function name) operation =lookup (symbol
if self.top==True:
operation=self.lookup_control(symbol,self.controls_list)
else:
operation=symbol
# print 'operation',operation
# if no match for symbol against standard operations then return
if operation=='':
return
else:
if self.shower<>None:
# if next lower show is running pass down operatin to the show and lower levels
self.shower.input_pressed(operation,source,edge)
else:
#service the standard inputs for this show
if operation=='stop':
if self.menu_timeout_running<>None:
self.canvas.after_cancel(self.menu_timeout_running)
self.menu_timeout_running=None
if self.shower<>None:
self.shower.input_pressed('stop',edge,source)
elif self.player<>None:
self.player.input_pressed('stop')
else:
# not at top so end the show
if self.top == False:
self.end('normal',"exit from stop command")
else:
pass
elif operation in ('up','down'):
# if child or sub-show running and is a show pass down
# if child not running - move
if self.shower<>None:
self.shower.input_pressed(operation,edge,source)
else:
if self.player==None:
if self.menu_timeout_running<>None:
self.canvas.after_cancel(self.menu_timeout_running)
self.menu_timeout_running=self.canvas.after(self.menu_timeout_value,self.timeout_menu)
if operation=='up':
self.previous()
else:
self.next()
elif operation =='play':
# if child running and is show - pass down
# if no track already running - play
if self.shower<>None:
self.shower.input_pressed(operation,edge,source)
else:
if self.player==None:
self.play_selected_track(self.medialist.selected_track())
elif operation == 'pause':
# pass down if show or track running.
if self.shower<>None:
self.shower.input_pressed(operation,edge,source)
elif self.player<>None:
self.player.input_pressed(operation)
elif operation[0:4]=='omx-' or operation[0:6]=='mplay-'or operation[0:5]=='uzbl-':
if self.player<>None:
self.player.input_pressed(operation)
def lookup_control(self,symbol,controls_list):
for control in controls_list:
if symbol == control[0]:
return control[1]
return ''
# *********************
# INTERNAL FUNCTIONS
# ********************
# *********************
# Sequencing
# *********************
def timeout_menu(self):
self.end('normal','menu timeout')
return
def next(self):
self.highlight_menu_entry(self.menu_index,False)
self.medialist.next('ordered')
if self.menu_index==self.menu_length-1:
self.menu_index=0
else:
self.menu_index+=1
self.highlight_menu_entry(self.menu_index,True)
def previous(self):
self.highlight_menu_entry(self.menu_index,False)
if self.menu_index==0:
self.menu_index=self.menu_length-1
else:
self.menu_index-=1
self.medialist.previous('ordered')
self.highlight_menu_entry(self.menu_index,True)
# at the end of a track just re-display the menu with the original callback from the menu
def what_next(self,message):
# user wants to end
if self.end_menushow_signal==True:
self.end_menushow_signal=False
self.end('normal',"show ended by user")
else:
self.do_menu()
# *********************
# Dispatching to Players
# *********************
def play_selected_track(self,selected_track):
""" selects the appropriate player from type field of the medialist and computes
the parameters for that type
selected track is a dictionary for the track/show
"""
#remove menu and show working.....
if self.menu_timeout_running<>None:
self.canvas.after_cancel(self.menu_timeout_running)
self.menu_timeout_running=None
self.canvas.delete('pp-content')
self.display_eggtimer(self.resource('menushow','m01'))
# dispatch track by type
self.player=None
self.shower=None
track_type = selected_track['type']
self.mon.log(self,"Track type is: "+ track_type)
if track_type=="video":
# create a videoplayer
track_file=self.complete_path(selected_track['location'])
self.player=VideoPlayer(self.show_id,self.root,self.canvas,self.show_params,selected_track,self.pp_dir,self.pp_home,self.pp_profile)
self.player.play(track_file,
self.showlist,
self.end_player,
self.delete_eggtimer,
enable_menu=False)
elif track_type=="audio":
# create a audioplayer
track_file=self.complete_path(selected_track['location'])
self.player=AudioPlayer(self.show_id,self.root,self.canvas,self.show_params,selected_track,self.pp_dir,self.pp_home,self.pp_profile)
self.player.play(track_file,
self.showlist,
self.end_player,
self.delete_eggtimer,
enable_menu=False)
elif track_type=="image":
# images played from menus don't have children
track_file=self.complete_path(selected_track['location'])
self.player=ImagePlayer(self.show_id,self.root,self.canvas,self.show_params,selected_track,self.pp_dir,self.pp_home,self.pp_profile)
self.player.play(track_file,
self.showlist,
self.end_player,
self.delete_eggtimer,
enable_menu=False,
)
elif track_type=="web":
# create a browser
track_file=self.complete_path(selected_track['location'])
self.player=BrowserPlayer(self.show_id,self.root,self.canvas,self.show_params,selected_track,self.pp_dir,self.pp_home,self.pp_profile)
self.player.play(track_file,
self.showlist,
self.end_player,
self.delete_eggtimer,
enable_menu=False)
elif track_type=="message":
# bit odd because MessagePlayer is used internally to display text.
text=selected_track['text']
self.player=MessagePlayer(self.show_id,self.root,self.canvas,self.show_params,selected_track,self.pp_dir,self.pp_home,self.pp_profile)
self.player.play(text,
self.showlist,
self.end_player,
self.delete_eggtimer,
enable_menu=False
)
elif track_type=="show":
# get the show from the showlist
index = self.showlist.index_of_show(selected_track['sub-show'])
if index >=0:
self.showlist.select(index)
selected_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show not found in showlist: "+ selected_track['sub-show'])
self.end("Unknown show")
if selected_show['type']=="mediashow":
self.shower= MediaShow(selected_show,
self.root,
self.canvas,
self.showlist,
self.pp_dir,
self.pp_home,
self.pp_profile)
self.shower.play(self.show_id,self.end_shower,self.delete_eggtimer,top=False,command='nil')
elif selected_show['type']=="liveshow":
self.shower= LiveShow(selected_show,
self.root,
self.canvas,
self.showlist,
self.pp_dir,
self.pp_home,
self.pp_profile)
self.shower.play(self.show_id,self.end_shower,self.delete_eggtimer,top=False,command='nil')
elif selected_show['type']=="radiobuttonshow":
self.shower= RadioButtonShow(selected_show,
self.root,
self.canvas,
self.showlist,
self.pp_dir,
self.pp_home,
self.pp_profile)
self.shower.play(self.show_id,self.end_shower,self.ready_callback,top=False,command='nil')
elif selected_show['type']=="hyperlinkshow":
self.shower= HyperlinkShow(selected_show,
self.root,
self.canvas,
self.showlist,
self.pp_dir,
self.pp_home,
self.pp_profile)
self.shower.play(self.show_id,self.end_shower,self.ready_callback,top=False,command='nil')
elif selected_show['type']=="menu":
self.shower= MenuShow(selected_show,
self.root,
self.canvas,
self.showlist,
self.pp_dir,
self.pp_home,
self.pp_profile)
self.shower.play(self.show_id,self.end_shower,self.delete_eggtimer,top=False,command='nil')
else:
self.mon.err(self,"Unknown Show Type: "+ selected_show['type'])
self.end("Unknown show type")
else:
self.mon.err(self,"Unknown Track Type: "+ track_type)
self.end("Unknown track type")
# callback from when player ends
def end_player(self,reason,message):
self.mon.log(self,"Returned from player with message: "+ message)
self.player=None
if reason in("killed","error"):
self.end(reason,message)
else:
self.display_eggtimer(self.resource('menushow','m02'))
self.what_next(message)
# callback from when shower ends
def end_shower(self,show_id,reason,message):
self.mon.log(self,"Returned from shower with message: "+ message)
self.shower=None
if reason in ("killed","error"):
self.end(reason,message)
else:
self.display_eggtimer(self.resource('menushow','m03'))
self.what_next(message)
# *********************
# Ending the show
# *********************
# finish the player for killing, error or normally
# this may be called directly if sub/child shows or players are not running
# if they might be running then need to call terminate?????
def end(self,reason,message):
self.mon.log(self,"Ending menushow: "+ self.show_params['show-ref'])
if self.menu_timeout_running<>None:
self.canvas.after_cancel(self.menu_timeout_running)
self.menu_timeout_running=None
self.end_callback(self.show_id,reason,message)
self=None
return
# *********************
# Displaying things
# *********************
def display_background(self):
pil_menu_img=PIL.Image.open(self.menu_img_file)
self.menu_background = PIL.ImageTk.PhotoImage(pil_menu_img)
self.drawn = self.canvas.create_image(int(self.canvas['width'])/2,
int(self.canvas['height'])/2,
image=self.menu_background,
anchor=CENTER,
tag='pp-content')
def display_new_menu(self):
# calculate menu geometry
error,reason=self.calculate_geometry()
if error<>'normal':
self.mon.err(self,"Menu geometry error: "+ reason)
self.end('error',"Menu geometry error")
else:
# display the menu entries
self.display_menu_entries()
def display_menu_entries(self):
# init the loop
column_index=0
row_index=0
self.menu_length=1
# id store is a list of elements each being a list of the three ids of the elements of the entry
self.menu_entry_id=[]
# offsets for the above
self.icon_id_index=0 # rectangle around the icon
self.image_id_index=1 # icon image - needed for tkinter
self.text_id_index=2 # the text - need whn no icon is displayed
#select the startof the medialist
self.medialist.start()
#loop through menu entries
while True:
#display the entry
#calculate top left corner of entry
self.calculate_entry_position(column_index,row_index)
# display the button strip
self.display_entry_strip()
#display the selected entry highlight
icon_id=self.display_icon_rectangle()
#display the image in the icon
image_id=self.display_icon_image()
if self.show_params['menu-text-mode']<>'none':
text_id=self.display_icon_text()
else:
text_id=None
#append id's to the list
self.menu_entry_id.append([icon_id,image_id,text_id])
self.canvas.update_idletasks( )
#and loop
if self.medialist.at_end():
break
self.menu_length+=1
self.medialist.next('ordered')
if self.direction=='horizontal':
column_index+=1
if column_index>=self.menu_columns:
column_index=0
row_index+=1
else:
row_index+=1
if row_index>=self.menu_rows:
row_index=0
column_index+=1
# finally select and highlight the first entry
self.medialist.start()
self.menu_index=0
self.highlight_menu_entry(self.menu_index,True)
def print_geometry(self,total_width,total_height):
print 'menu width: ', self.menu_width
print 'columns', self.menu_columns
print 'icon width: ', self.icon_width
print 'horizontal padding: ', self.menu_horizontal_padding
print 'text width: ', self.text_width
print 'entry width: ', self.entry_width
print 'total width: ', total_width
print 'x separation: ', self.x_separation
print ''
print 'menu height', self.menu_height
print 'rows: ', self.menu_rows
print 'icon height', self.icon_height
print 'vertical padding: ', self.menu_vertical_padding
print 'text height', self.text_height
print 'entry height', self.entry_height
print 'total height', total_height
print 'y separation', self.y_separation
# ------------------------------------------------------------------
#calculate menu entry size and separation between menu entries
# ------------------------------------------------------------------
def calculate_geometry(self):
self.display_strip=self.show_params['menu-strip']
self.screen_width=int(self.canvas['width'])
self.screen_height=int(self.canvas['height'])
if self.display_strip=='yes':
self.strip_padding=int(self.show_params['menu-strip-padding'])
else:
self.strip_padding=0
# parse the menu window
error,reason,self.menu_x_left,self.menu_y_top,self.menu_x_right,self.menu_y_bottom=self.parse_menu_window(self.show_params['menu-window'])
if error<>'normal':
return 'error',"Menu Window error: "+ reason
if self.show_params['menu-icon-mode']=='none' and self.show_params['menu-text-mode']=='none':
return 'error','Icon and Text are both None'
if self.show_params['menu-icon-mode']=='none' and self.show_params['menu-text-mode']=='overlay':
return 'error','cannot overlay none icon'
self.direction=self.show_params['menu-direction']
self.menu_width=self.menu_x_right - self.menu_x_left
self.menu_height=self.menu_y_bottom - self.menu_y_top
self.list_length=self.medialist.display_length()
# get or calculate rows and columns
if self.direction=='horizontal':
if self.show_params['menu-columns']=='':
return 'error','blank columns for horizontal direction'
self.menu_columns=int(self.show_params['menu-columns'])
self.menu_rows=self.list_length//self.menu_columns
if self.list_length % self.menu_columns<>0:
self.menu_rows+=1
else:
if self.show_params['menu-rows']=='':
return 'error','blank rows for vertical direction'
self.menu_rows=int(self.show_params['menu-rows'])
self.menu_columns=self.list_length//self.menu_rows
if self.list_length % self.menu_rows<>0:
self.menu_columns+=1
self.x_separation=int(self.show_params['menu-horizontal-separation'])
self.y_separation=int(self.show_params['menu-vertical-separation'])
# get size of padding depending on exitence of icon and text
if self.show_params['menu-icon-mode'] in ('thumbnail','bullet') and self.show_params['menu-text-mode'] == 'right':
self.menu_horizontal_padding=int(self.show_params['menu-horizontal-padding'])
else:
self.menu_horizontal_padding=0
if self.show_params['menu-icon-mode'] in ('thumbnail','bullet') and self.show_params['menu-text-mode'] == 'below':
self.menu_vertical_padding=int(self.show_params['menu-vertical-padding'])
else:
self.menu_vertical_padding=0
#calculate size of icon depending on use
if self.show_params['menu-icon-mode'] in ('thumbnail','bullet'):
self.icon_width=int(self.show_params['menu-icon-width'])
self.icon_height=int(self.show_params['menu-icon-height'])
else:
self.icon_width=0
self.icon_height=0
#calculate size of text box depending on mode
if self.show_params['menu-text-mode']<>'none':
self.text_width=int(self.show_params['menu-text-width'])
self.text_height=int(self.show_params['menu-text-height'])
else:
self.text_width=0
self.text_height=0
# calculate size of entry box by combining text and icon sizes
if self.show_params['menu-text-mode'] == 'right':
self.entry_width=self.icon_width+self.menu_horizontal_padding+self.text_width
self.entry_height=max(self.text_height,self.icon_height)
elif self.show_params['menu-text-mode']=='below':
self.entry_width=max(self.text_width,self.icon_width)
self.entry_height=self.icon_height + self.menu_vertical_padding + self.text_height
else:
# no text or overlaid text
if self.show_params['menu-icon-mode'] in ('thumbnail','bullet'):
# icon only
self.entry_width=self.icon_width
self.entry_height=self.icon_height
else:
#text only
self.entry_width=self.text_width
self.entry_height=self.text_height
if self.entry_width<=self.menu_horizontal_padding:
return 'error','entry width is zero'
if self.entry_height<=self.menu_vertical_padding:
return 'error','entry height is zero'
# calculate totals for debugging puropses
total_width=self.menu_columns * self.entry_width +(self.menu_columns-1)*self.x_separation
total_height=self.menu_rows * self.entry_height + (self.menu_rows-1)*self.y_separation
# self.print_geometry(total_width,total_height)
# display guidelines and debgging text if there is a problem
if total_width>self.menu_width and self.display_guidelines<>'never':
self.display_guidelines='always'
self.mon.log(self,'\nMENU IS WIDER THAN THE WINDOW')
self.print_geometry(total_width,total_height)
if total_height>self.menu_height and self.display_guidelines<>'never':
self.display_guidelines='always'
self.mon.log(self,'\nMENU IS TALLER THAN THE WINDOW')
self.print_geometry(total_width,total_height)
# display calculated total rectangle guidelines for debugging
if self.display_guidelines=='always':
points=[self.menu_x_left,self.menu_y_top, self.menu_x_left+total_width,self.menu_y_top+total_height]
# and display the icon rectangle
self.canvas.create_rectangle(points,
outline='red',
fill='',
tag='pp-content')
# display menu rectangle guidelines for debugging
if self.display_guidelines=='always':
points=[self.menu_x_left,self.menu_y_top, self.menu_x_right,self.menu_y_bottom]
self.canvas.create_rectangle(points,
outline='blue',
fill='',
tag='pp-content')
return 'normal',''
def calculate_entry_position(self,column_index,row_index):
self.entry_x=self.menu_x_left+ column_index*(self.x_separation+self.entry_width)
self.entry_y=self.menu_y_top+ row_index*(self.y_separation+self.entry_height)
def display_entry_strip(self):
if self.display_strip=='yes':
if self.direction=='vertical':
#display the strip
strip_points=[self.entry_x - self.strip_padding -1 ,
self.entry_y - self.strip_padding - 1,
self.entry_x+ self.entry_width + self.strip_padding - 1,
self.entry_y+self.entry_height+ self.strip_padding - 1]
self.canvas.create_rectangle(strip_points,
outline='',
fill='gray',
stipple='gray12',
tag='pp-content')
top_l_points=[self.entry_x - self.strip_padding,
self.entry_y - self.strip_padding,
self.entry_x + self.entry_width + self.strip_padding ,
self.entry_y - self.strip_padding]
self.canvas.create_line(top_l_points,
fill='light gray',
tag='pp-content')
bottom_l_points=[self.entry_x - self.strip_padding,
self.entry_y + self.entry_height + self.strip_padding,
self.entry_x+ self.entry_width + self.strip_padding ,
self.entry_y+ self.entry_height + self.strip_padding]
self.canvas.create_line(bottom_l_points,
fill='dark gray',
tag='pp-content')
left_l_points=[self.entry_x - self.strip_padding,
self.entry_y - self.strip_padding,
self.entry_x - self.strip_padding,
self.entry_y + self.entry_height + self.strip_padding]
self.canvas.create_line(left_l_points,
fill='gray',
tag='pp-content')
else:
#display the strip vertically
strip_points=[self.entry_x - self.strip_padding +1 ,
self.entry_y - self.strip_padding +1,
self.entry_x+self.entry_width + self.strip_padding -1,
self.entry_y + self.entry_height+ self.strip_padding -1]
self.canvas.create_rectangle(strip_points,
outline='',
fill='gray',
stipple='gray12',
tag='pp-content')
top_l_points=[self.entry_x - self.strip_padding,
self.entry_y - self.strip_padding,
self.entry_x + self.entry_width + self.strip_padding,
self.entry_y - self.strip_padding]
self.canvas.create_line(top_l_points,
fill='light gray',
tag='pp-content')
left_l_points=[self.entry_x - self.strip_padding,
self.entry_y - self.strip_padding,
self.entry_x - self.strip_padding,
self.entry_y + self.entry_height+ self.strip_padding]
self.canvas.create_line(left_l_points,
fill='gray',
tag='pp-content')
right_l_points=[self.entry_x +self.entry_width + self.strip_padding,
self.entry_y - self.strip_padding,
self.entry_x +self.entry_width + self.strip_padding,
self.entry_y + self.entry_height+ self.strip_padding]
self.canvas.create_line(right_l_points,
fill='dark gray',
tag='pp-content')
# display the rectangle that goes arond the icon when the entry is selected
def display_icon_rectangle(self):
if self.show_params['menu-icon-mode'] in ('thumbnail','bullet'):
#calculate icon parameters
if self.icon_width<self.text_width and self.show_params['menu-text-mode']=='below':
self.icon_x_left=self.entry_x+abs(self.icon_width-self.text_width)/2
else:
self.icon_x_left=self.entry_x
self.icon_x_right=self.icon_x_left+self.icon_width
if self.icon_height<self.text_height and self.show_params['menu-text-mode']=='right':
self.icon_y_top=self.entry_y+abs(self.icon_height-self.text_height)/2
else:
self.icon_y_top=self.entry_y
self.icon_y_bottom=self.icon_y_top+self.icon_height
req_horiz_sep=self.menu_horizontal_padding
req_vert_sep=self.menu_vertical_padding
points=[self.icon_x_left,self.icon_y_top,self.icon_x_right,self.icon_y_top,self.icon_x_right,self.icon_y_bottom,self.icon_x_left,self.icon_y_bottom]
# display guidelines make it white when not selctedfor debugging
if self.display_guidelines=='always':
outline='white'
else:
outline=''
# and display the icon rectangle
icon_id=self.canvas.create_polygon(points,
outline=outline,
fill='',
tag='pp-content')
else:
# not using icon so set starting point for text to zero icon size
self.icon_x_right=self.entry_x
self.icon_y_bottom=self.entry_y
req_horiz_sep=0
req_vert_sep=0
icon_id=None
return icon_id
#display the image in a menu entry
def display_icon_image(self):
image_id=None
if self.show_params['menu-icon-mode'] == 'thumbnail':
# try for the thumbnail
if self.medialist.selected_track()['thumbnail']<>'' and os.path.exists(self.complete_path(self.medialist.selected_track()['thumbnail'])):
self.pil_image=PIL.Image.open(self.complete_path(self.medialist.selected_track()['thumbnail']))
else:
#cannot find thumbnail get the image if its an image track
if self.medialist.selected_track()['type'] =='image':
self.track=self.complete_path(self.medialist.selected_track()['location'])
else:
self.track=''
if self.medialist.selected_track()['type']=='image' and os.path.exists(self.track)==True:
self.pil_image=PIL.Image.open(self.track)
else:
#use a standard thumbnail
type=self.medialist.selected_track()['type']
standard=self.pp_dir+os.sep+'pp_home'+os.sep+'pp_resources'+os.sep+type+'.png'
if os.path.exists(standard)==True:
self.pil_image=PIL.Image.open(standard)
self.mon.log(self,'WARNING: default thumbnail used for '+self.medialist.selected_track()['title'])
else:
self.pil_image=None
# display the image
if self.pil_image<>None:
self.pil_image=self.pil_image.resize((self.icon_width-2,self.icon_height-2))
image_id=PIL.ImageTk.PhotoImage(self.pil_image)
self.canvas.create_image(self.icon_x_left+1, self.icon_y_top+1,
image=image_id, anchor=NW,
tag='pp-content')
else:
image_id=None
elif self.show_params['menu-icon-mode'] =='bullet':
bullet=self.complete_path(self.show_params['menu-bullet'])
if os.path.exists(bullet)==False:
self.pil_image=None
else:
self.pil_image=PIL.Image.open(bullet)
if self.pil_image<>None:
self.pil_image=self.pil_image.resize((self.icon_width-2,self.icon_height-2))
image_id=PIL.ImageTk.PhotoImage(self.pil_image)
self.canvas.create_image(self.icon_x_left+1, self.icon_y_top+1,
image=image_id, anchor=NW,
tag='pp-content')
else:
image_id=None
return image_id
#display the text of a menu entry
def display_icon_text(self):
text_mode=self.show_params['menu-text-mode']
if self.show_params['menu-icon-mode'] in ('thumbnail','bullet'):
if text_mode=='right':
if self.icon_height>self.text_height:
text_y_top=self.entry_y+abs(self.icon_height-self.text_height)/2
else:
text_y_top=self.entry_y
text_y_bottom=text_y_top+self.text_height
text_x_left=self.icon_x_right+self.menu_horizontal_padding
text_x_right=text_x_left+self.text_width
text_x=text_x_left
text_y=text_y_top+(self.text_height/2)
elif text_mode=='below':
text_y_top=self.icon_y_bottom+self.menu_vertical_padding
text_y_bottom=text_y_top+self.text_height
if self.icon_width>self.text_width:
text_x_left=self.entry_x+abs(self.icon_width-self.text_width)/2
else:
text_x_left=self.entry_x
text_x_right=text_x_left+self.text_width
text_x=text_x_left+(self.text_width/2)
text_y=text_y_top
else:
# icon with text_mode=overlay or none
text_x_left=self.icon_x_left
text_x_right= self.icon_x_right
text_y_top=self.icon_y_top
text_y_bottom=self.icon_y_bottom
text_x=(text_x_left+text_x_right)/2
text_y=(text_y_top+text_y_bottom)/2
else:
#no icon text only
text_y_top=self.entry_y
text_y_bottom=text_y_top+self.text_height
text_x_left=self.entry_x
text_x_right=text_x_left+self.text_width
text_x=self.entry_x
text_y=self.entry_y+self.text_height/2
#display the guidelines for debugging
if self.display_guidelines=='always':
points=[text_x_left,text_y_top,text_x_right,text_y_top,text_x_right,text_y_bottom,text_x_left,text_y_bottom]
self.canvas.create_polygon(points,fill= '' ,
outline='white',
tag='pp-content')
# display the text
if text_mode=='below' and self.show_params['menu-icon-mode'] in ('thumbnail','bullet'):
anchor=N
justify=CENTER
elif text_mode=='overlay' and self.show_params['menu-icon-mode'] in ('thumbnail','bullet'):
anchor=CENTER
justify=CENTER
else:
anchor=W
justify=LEFT
text_id=self.canvas.create_text(text_x,text_y,
text=self.medialist.selected_track()['title'],
anchor=anchor,
fill=self.show_params['entry-colour'],
font=self.show_params['entry-font'],
width=self.text_width,
justify=justify,
tag='pp-content')
return text_id
def highlight_menu_entry(self,index,state):
if self.show_params['menu-icon-mode']<>'none':
if state==True:
self.canvas.itemconfig(self.menu_entry_id[index][self.icon_id_index],
outline=self.show_params['entry-select-colour'],
width=4,
)
else:
self.canvas.itemconfig(self.menu_entry_id[index][self.icon_id_index],
outline='',
width=1
)
else:
if state==True:
self.canvas.itemconfig(self.menu_entry_id[index][self.text_id_index],
fill=self.show_params['entry-select-colour'])
else:
self.canvas.itemconfig(self.menu_entry_id[index][self.text_id_index],
fill=self.show_params['entry-colour'])
def display_eggtimer(self,text):
# print "display eggtimer"
self.canvas.create_text(int(self.canvas['width'])/2,
int(self.canvas['height'])/2,
text= text,
fill='white',
font="Helvetica 20 bold",
tag='pp-eggtimer')
self.canvas.update_idletasks( )
def delete_eggtimer(self):
# print"delete eggtimer"
self.canvas.delete('pp-eggtimer')
self.canvas.update_idletasks( )
# *********************
# utilities
# *********************
def complete_path(self,track_file):
# complete path of the filename of the selected entry
if track_file<>'' and track_file[0]=="+":
track_file=self.pp_home+track_file[1:]
return track_file
def parse_menu_window(self,line):
if line<>'':
fields = line.split()
if len(fields) not in (1, 2,4):
return 'error','wrong number of fields',0,0,0,0
if len(fields)==1:
if fields[0]=='fullscreen':
return 'normal','',0,0,self.screen_width - 1, self.screen_height - 1
else:
return 'error','single field is not fullscreen',0,0,0,0
if len(fields)==2:
if fields[0].isdigit() and fields[1].isdigit():
return 'normal','',int(fields[0]),int(fields[1]),self.screen_width, self.screen_height
else:
return 'error','field is not a digit',0,0,0,0
if len(fields)==4:
if fields[0].isdigit() and fields[1].isdigit() and fields[2].isdigit() and fields[3].isdigit():
return 'normal','',int(fields[0]),int(fields[1]),int(fields[2]),int(fields[3])
else:
return 'error','field is not a digit',0,0,0,0
else:
return 'error','line is blank',0,0,0,0
def resource(self,section,item):
value=self.rr.get(section,item)
if value==False:
self.mon.err(self, "resource: "+section +': '+ item + " not found" )
# timers may be running so need terminate
self.terminate("error")
else:
return value
class MenuShow(Show):
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
self.controlsmanager=ControlsManager()
# init variables
self.show_timeout_timer=None
self.track_timeout_timer=None
self.next_track_signal=False
self.next_track=None
self.menu_index=0
self.menu_showing=True
self.req_next=''
def play(self,end_callback,show_ready_callback,parent_kickback_signal,level,controls_list):
""" displays the menu
end_callback - function to be called when the menu exits
show_ready_callback - callback when menu is ready to display (not used)
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal - not used other than it being passed to a show
"""
# need to instantiate the medialist here as not using gapshow
self.medialist=MediaList('ordered')
Show.base_play(self,end_callback,show_ready_callback, parent_kickback_signal,level,controls_list)
self.mon.trace(self,self.show_params['show-ref'])
#parse the show and track timeouts
reason,message,self.show_timeout=Show.calculate_duration(self,self.show_params['show-timeout'])
if reason =='error':
self.mon.err(self,'Show Timeout has bad time: '+self.show_params['show-timeout'])
self.end('error','show timeout, bad time')
reason,message,self.track_timeout=Show.calculate_duration(self,self.show_params['track-timeout'])
if reason=='error':
self.mon.err(self,'Track Timeout has bad time: '+self.show_params['track-timeout'])
self.end('error','track timeout, bad time')
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
# and display the menu
self.do_menu_track()
# ********************
# respond to inputs.
# ********************
# exit received from another concurrent show
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# terminate Pi Presents
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
def handle_input_event(self,symbol):
Show.base_handle_input_event(self,symbol)
def handle_input_event_this_show(self,symbol):
# menushow has only internal operation
operation=self.base_lookup_control(symbol,self.controls_list)
self.do_operation(operation)
def do_operation(self,operation):
# service the standard inputs for this show
self.mon.trace(self,operation)
if operation =='exit':
self.exit()
elif operation == 'stop':
self.stop_timers()
if self.current_player is not None:
if self.menu_showing is True and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal=True
self.current_player.input_pressed('stop')
elif operation in ('up','down'):
# stop show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
# and start it again
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout*1000,self.show_timeout_stop)
if operation=='up':
self.previous()
else:
self.next()
elif operation =='play':
self.next_track_signal=True
self.next_track=self.medialist.selected_track()
self.current_player.stop()
# cancel show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
# stop current track (the menuplayer) if running or just start the next track
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
self.what_next_after_showing()
elif operation in ('no-command','null'):
return
elif operation == 'pause':
if self.current_player is not None:
self.current_player.input_pressed(operation)
elif operation[0:4]=='omx-' or operation[0:6]=='mplay-'or operation[0:5]=='uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(operation)
def next(self):
# remove highlight
if self.current_player.__class__.__name__ == 'MenuPlayer':
self.current_player.highlight_menu_entry(self.menu_index,False)
self.medialist.next('ordered')
if self.menu_index==self.menu_length-1:
self.menu_index=0
else:
self.menu_index+=1
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index,True)
def previous(self):
# remove highlight
if self.current_player.__class__.__name__ == 'MenuPlayer':
self.current_player.highlight_menu_entry(self.menu_index,False)
if self.menu_index==0:
self.menu_index=self.menu_length-1
else:
self.menu_index-=1
self.medialist.previous('ordered')
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index,True)
# *********************
# Sequencing
# *********************
def track_timeout_callback(self):
self.do_operation('stop')
def do_menu_track(self):
self.menu_showing=True
self.mon.trace(self,'')
# start show timeout alarm if required
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout *1000,self.show_timeout_stop)
# init the index used to hiighlight the selected menu entry by menuplayer
self.menu_index=0
index = self.medialist.index_of_track(self.show_params['menu-track-ref'])
if index == -1:
self.mon.err(self,"'menu-track' not in medialist: " + self.show_params['menu-track-ref'])
self.end('error',"menu-track not in medialist: ")
return
#make the medialist available to the menuplayer for cursor scrolling
self.show_params['medialist_obj']=self.medialist
# load the menu track
self.start_load_show_loop(self.medialist.track(index))
# *********************
# Playing show or track loop
# *********************
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)
# track has loaded (menu or otherwise) so show it.
def what_next_after_load(self,status,message):
# get the calculated length of the menu for the loaded menu track
if self.current_player.__class__.__name__ == 'MenuPlayer':
if self.medialist.display_length()==0:
self.req_next='error'
self.what_next_after_showing()
return
self.medialist.start()
self.menu_index=0
self.menu_length=self.current_player.menu_length
self.current_player.highlight_menu_entry(self.menu_index,True)
self.mon.trace(self,' - load complete with status: ' + status + ' message: ' + message)
if self.current_player.play_state=='load-failed':
self.req_next='error'
self.what_next_after_showing()
else:
if self.show_timeout_signal is True or self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self,'')
self.current_player.show(self.track_ready_callback,self.finished_showing,self.closed_after_showing)
def finished_showing(self,reason,message):
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self,'')
self.mon.log(self,"pause at end of showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='finished-player'
self.what_next_after_showing()
def closed_after_showing(self,reason,message):
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self,'')
self.mon.log(self,"Closed after showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='closed-player'
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self,show_id,reason,message):
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ': Returned from shower with ' + reason +' ' + message)
self.sr.hide_click_areas(self.controls_list)
self.req_next=reason
Show.base_end_shower(self)
self.what_next_after_showing()
# at the end of a track check for terminations else re-display the menu
def what_next_after_showing(self):
self.mon.trace(self,'')
# cancel track timeout timer
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
# need to terminate?
if self.terminate_signal is True:
self.terminate_signal=False
# set what to do when closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.req_next== 'error':
self.req_next=''
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
# set what to do when closed or unloaded
self.ending_reason='show-timeout'
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal=False
self.ending_reason='exit'
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal=False
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
elif self.next_track_signal is True:
self.next_track_signal=False
self.menu_showing=False
# start timeout for the track if required
if self.track_timeout != 0:
self.track_timeout_timer=self.canvas.after(self.track_timeout*1000,self.track_timeout_callback)
Show.write_stats(self,'play',self.show_params,self.next_track)
self.start_load_show_loop(self.next_track)
else:
# no stopping the show required so re-display the menu
self.do_menu_track()
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self,enable_show_background):
self.delete_eggtimer()
if self.show_params['disable-controls'] != 'yes':
#merge controls from the track
controls_text=self.current_player.get_links()
reason,message,track_controls=self.controlsmanager.parse_controls(controls_text)
if reason == 'error':
self.mon.err(self,message + " in track: "+ self.current_player.track_params['track-ref'])
self.req_next='error'
self.what_next_after_showing()
self.controlsmanager.merge_controls(self.controls_list,track_controls)
self.sr.enable_click_areas(self.controls_list)
Show.base_track_ready_callback(self,enable_show_background)
# callback from begining of a subshow, provide previous shower player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# Ending the show
# *********************
def end(self,reason,message):
self.stop_timers()
Show.base_end(self,reason,message)
def stop_timers(self):
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
