class Record(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
if Gst.version() == (1, 0, 10, 0):
return self._incompatible()
# for fullscreen feature, use local rather than toolkit
self.props.enable_fullscreen_mode = False
self._state = None
Instance(self)
# the main classes
self.model = Model(self)
self.ui_init()
# CSCL
self.connect("shared", self._shared_cb)
if self.get_shared_activity():
# have you joined or shared this activity yourself?
if self.get_shared():
self._joined_cb(self)
else:
self.connect("joined", self._joined_cb)
# Changing to the first toolbar kicks off the rest of the setup
if self.model.get_cameras():
self.model.change_mode(constants.MODE_PHOTO)
else:
self.model.change_mode(constants.MODE_AUDIO)
# Start live video pipeline when the video window becomes visible
def on_defer_cb():
self.model.set_visible(True)
self.connect("notify::active", self.__active_cb)
return False
def on_event_cb(widget, event):
if event.state == Gdk.VisibilityState.UNOBSCURED:
GLib.timeout_add(50, on_defer_cb)
self._media_view._video.disconnect_by_func(on_event_cb)
self._media_view._video.add_events(
Gdk.EventMask.VISIBILITY_NOTIFY_MASK)
self._media_view._video.connect('visibility-notify-event', on_event_cb)
def _incompatible(self):
''' Display abbreviated activity user interface with alert '''
toolbox = ToolbarBox()
stop = StopButton(self)
toolbox.toolbar.add(stop)
self.set_toolbar_box(toolbox)
title = _('Activity not compatible with this system.')
msg = _('Please downgrade activity and try again.')
alert = Alert(title=title, msg=msg)
alert.add_button(0, 'Stop', Icon(icon_name='activity-stop'))
self.add_alert(alert)
label = Gtk.Label(_('Uh oh, GStreamer is too old.'))
self.set_canvas(label)
alert.connect('response', self.__incompatible_response_cb)
stop.connect('clicked', self.__incompatible_stop_clicked_cb,
alert)
self.show_all()
def __incompatible_stop_clicked_cb(self, button, alert):
self.remove_alert(alert)
def __incompatible_response_cb(self, alert, response):
self.remove_alert(alert)
self.close()
def read_file(self, path):
if hasattr(self, 'model'):
self.model.read_file(path)
def write_file(self, path):
if hasattr(self, 'model'):
self.model.write_file(path)
def close(self, **kwargs):
if hasattr(self, 'model'):
self.model.close()
activity.Activity.close(self, **kwargs)
def __active_cb(self, widget, pspec):
self.model.set_visible(self.props.active)
def _shared_cb(self, activity):
self.model.collab.set_activity_shared()
def _joined_cb(self, activity):
self.model.collab.joined()
def ui_init(self):
self._fullscreen = False
self._showing_info = False
# FIXME: if _thumb_tray becomes some kind of button group, we wouldn't
# have to track which recd is active
self._active_recd = None
self.connect('key-press-event', self._key_pressed)
self._active_toolbar_idx = 0
toolbar_box = ToolbarBox()
self._activity_toolbar_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self._activity_toolbar_button, 0)
self.set_toolbar_box(toolbar_box)
self._toolbar = self.get_toolbar_box().toolbar
tool_group = None
if self.model.get_cameras():
self._photo_button = RadioToolButton()
self._photo_button.props.group = tool_group
tool_group = self._photo_button
self._photo_button.props.icon_name = 'camera-external'
self._photo_button.props.label = _('Photo')
self._photo_button.props.accelerator = '<ctrl>1'
self._photo_button.props.tooltip = _(
'Picture camera mode\n\n'
'When the record button is pressed,\n'
'take one picture from the camera.')
self._photo_button.mode = constants.MODE_PHOTO
self._photo_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._photo_button, -1)
self._video_button = RadioToolButton()
self._video_button.props.group = tool_group
self._video_button.props.icon_name = 'media-video'
self._video_button.props.accelerator = '<ctrl>2'
self._video_button.props.label = _('Video')
self._video_button.props.tooltip = _(
'Video camera mode\n\n'
'When the record button is pressed,\n'
'take photographs many times a second,\n'
'and record sound using the microphone,\n'
'until the button is pressed again.')
self._video_button.mode = constants.MODE_VIDEO
self._video_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._video_button, -1)
else:
self._photo_button = None
self._video_button = None
self._audio_button = RadioToolButton()
self._audio_button.props.group = tool_group
self._audio_button.props.icon_name = 'media-audio'
self._audio_button.props.accelerator = '<ctrl>3'
self._audio_button.props.label = _('Audio')
self._audio_button.props.tooltip = _(
'Audio recording mode\n\n'
'When the record button is pressed,\n'
'take one photograph,\n'
'and record sound using the microphone,\n'
'until the button is pressed again.')
self._audio_button.mode = constants.MODE_AUDIO
self._audio_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._audio_button, -1)
self._toolbar.insert(Gtk.SeparatorToolItem(), -1)
self._mirror_btn = ToggleToolButton('mirror-horizontal')
self._mirror_btn.set_tooltip(_(
'Mirror view\n\n'
'Swap left for right, as if looking at a mirror.\n'
'Does not affect recording.'))
self._mirror_btn.props.accelerator = '<ctrl>m'
self._mirror_btn.show()
self._mirror_btn.connect('toggled', self.__mirror_toggled_cb)
self._toolbar.insert(self._mirror_btn, -1)
self._toolbar_controls = RecordControl(self._toolbar)
if self.model.get_cameras() and len(self.model.get_cameras()) > 1:
switch_camera_btn = ToolButton('switch-camera')
switch_camera_btn.set_tooltip(_('Switch camera'))
switch_camera_btn.show()
switch_camera_btn.connect('clicked', self.__switch_camera_click_cb)
self._toolbar.insert(switch_camera_btn, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._toolbar.insert(separator, -1)
self._toolbar.insert(StopButton(self), -1)
self.get_toolbar_box().show_all()
self._media_view = MediaView()
self._media_view.connect('media-clicked',
self._media_view_media_clicked)
self._media_view.connect('pip-clicked', self._media_view_pip_clicked)
self._media_view.connect('info-clicked', self._media_view_info_clicked)
self._media_view.connect('fullscreen-clicked',
self._media_view_fullscreen_clicked)
self._media_view.connect('tags-changed', self._media_view_tags_changed)
self._media_view.show()
self._controls_hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
trim_height_shutter_button = 7
self._controls_hbox.set_size_request(-1, style.GRID_CELL_SIZE +
trim_height_shutter_button)
self._shutter_button = ShutterButton()
self._shutter_button.connect("clicked", self._shutter_clicked)
self._shutter_button.modify_bg(Gtk.StateType.NORMAL, COLOR_BLACK)
self._controls_hbox.pack_start(self._shutter_button, True, False, 0)
self._countdown_image = CountdownImage()
self._controls_hbox.pack_start(self._countdown_image, True, False, 0)
self._play_button = PlayButton()
self._play_button.connect('clicked', self._play_pause_clicked)
self._controls_hbox.pack_start(self._play_button, False, True, 0)
self._playback_scale = PlaybackScale(self.model)
self._controls_hbox.pack_start(self._playback_scale, True, True, 0)
self._progress = ProgressInfo()
self._controls_hbox.pack_start(self._progress, True, True, 0)
self._title_label = Gtk.Label()
self._title_label.set_markup("<b><span foreground='white'>" +
_('Title:') + '</span></b>')
self._controls_hbox.pack_start(self._title_label, False, True, 0)
self._title_entry = Gtk.Entry()
self._title_entry.modify_bg(Gtk.StateType.INSENSITIVE, COLOR_BLACK)
self._title_entry.connect('changed', self._title_changed)
self._controls_hbox.pack_start(self._title_entry, expand=True,
fill=True, padding=10)
self._controls_hbox.show()
height_tray = 150 # height of tray
self._thumb_tray = HTray(hexpand=True, height_request=height_tray)
self._thumb_tray.show()
height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 2 - \
height_tray - trim_height_shutter_button
self._media_view.set_size_request(-1, height)
self._grid = Gtk.Grid(orientation=Gtk.Orientation.VERTICAL)
self._media_view.props.hexpand = True
self._media_view.props.vexpand = True
for row in [self._media_view, self._controls_hbox, self._thumb_tray]:
self._grid.add(row)
self._grid.modify_bg(Gtk.StateType.NORMAL, COLOR_BLACK)
self._grid.show()
self.set_canvas(self._grid)
def set_title_visible(self, visible):
self._grid.remove(self._controls_hbox)
if visible:
self._grid.attach_next_to(self._controls_hbox, self._media_view,
Gtk.PositionType.TOP, 1, 1)
else:
self._grid.attach_next_to(self._controls_hbox, self._media_view,
Gtk.PositionType.BOTTOM, 1, 1)
def __switch_camera_click_cb(self, btn):
self.model.switch_camera()
def __mirror_toggled_cb(self, button):
self.model.set_mirror(button.props.active)
def serialize(self):
data = {}
data['timer'] = self._toolbar_controls.get_timer_idx()
data['duration'] = self._toolbar_controls.get_duration_idx()
data['quality'] = self._toolbar_controls.get_quality()
return data
def deserialize(self, data):
self._toolbar_controls.set_timer_idx(data.get('timer', 0))
self._toolbar_controls.set_duration_idx(data.get('duration', 0))
self._toolbar_controls.set_quality(data.get('quality', 0))
def _key_pressed(self, widget, event):
key = event.keyval
ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
# while activity toolbar is visible, only escape key is taken
if self._activity_toolbar_button.is_expanded():
if key == Gdk.KEY_Escape:
self._activity_toolbar_button.set_expanded(False)
return True
return False
# while title is focused, only escape key is taken
if self._title_entry.is_focus():
if key == Gdk.KEY_Escape:
self.model.set_state(constants.STATE_READY)
return False
# while info tags are focused, only escape key is taken
if self._media_view.info_view.textview.is_focus():
if key == Gdk.KEY_Escape:
self.model.set_state(constants.STATE_READY)
return False
if ctrl and key == Gdk.KEY_f:
self._toggle_fullscreen()
return True
if ctrl and key == Gdk.KEY_s:
self.model.glive.stop()
return True
if ctrl and key == Gdk.KEY_p:
self.model.glive.play()
return True
if (ctrl and key == Gdk.KEY_space) or \
(ctrl and key == Gdk.KEY_r) or \
key == Gdk.KEY_KP_Page_Up: # game key O
if self._shutter_button.props.visible:
if self._shutter_button.props.sensitive:
self._shutter_button.clicked()
else: # return to live mode
self.model.set_state(constants.STATE_READY)
return True
if key == Gdk.KEY_space and self._active_recd:
if self._active_recd.type in (constants.TYPE_VIDEO,
constants.TYPE_AUDIO):
self.model.play_pause()
return True
# if viewing media, return to live mode
if key == Gdk.KEY_Escape and self._active_recd:
self.model.set_state(constants.STATE_READY)
return True
if self.model.ui_frozen():
return True
if ctrl and key == Gdk.KEY_c:
self._copy_to_clipboard(self._active_recd)
return True
if key == Gdk.KEY_i and self._active_recd:
self._toggle_info()
return True
if key == Gdk.KEY_Escape and self._fullscreen:
self._toggle_fullscreen()
return True
return False
def _play_pause_clicked(self, widget):
self.model.play_pause()
def set_mode(self, mode):
self._toolbar_controls.set_mode(mode)
# can be called from GStreamer thread, so must not do any GTK+ stuff
def set_glive_sink(self, sink):
return self._media_view.set_video_sink(sink)
# can be called from GStreamer thread, so must not do any GTK+ stuff
def set_gplay_sink(self, sink):
return self._media_view.set_video2_sink(sink)
def get_selected_quality(self):
return self._toolbar_controls.get_quality()
def get_selected_timer(self):
return self._toolbar_controls.get_timer()
def get_selected_duration(self):
return self._toolbar_controls.get_duration() * 60 # convert to secs
def set_progress(self, value, text):
self._progress.set_progress(value)
self._progress.set_text(text)
def set_countdown(self, value):
if value == 0:
self._shutter_button.show()
self._countdown_image.hide()
return
self._shutter_button.hide()
self._countdown_image.show()
self._countdown_image.set_value(value)
def _title_changed(self, widget):
self._active_recd.setTitle(self._title_entry.get_text())
def _media_view_media_clicked(self, widget):
if self._play_button.props.visible and \
self._play_button.props.sensitive:
self._play_button.clicked()
def _media_view_pip_clicked(self, widget):
# clicking on the PIP always returns to live mode
self.model.set_state(constants.STATE_READY)
def _media_view_info_clicked(self, widget):
self._toggle_info()
def _toggle_info(self):
recd = self._active_recd
if not recd:
return
if self._showing_info:
self._show_recd(recd, play=False)
return
self._showing_info = True
still_modes = (constants.MODE_PHOTO, constants.MODE_AUDIO)
if self.model.get_mode() in still_modes:
func = self._media_view.show_info_photo
else:
func = self._media_view.show_info_video
self._play_button.hide()
self._progress.hide()
self._playback_scale.hide()
self._title_entry.set_text(recd.title)
self._title_entry.show()
self._title_label.show()
self.set_title_visible(True)
func(recd.recorderName, recd.colorStroke, recd.colorFill,
utils.getDateString(recd.time), recd.tags)
def _media_view_fullscreen_clicked(self, widget):
# logger.debug('_media_view_fullscreen_clicked')
self._toggle_fullscreen()
def _media_view_tags_changed(self, widget, tbuffer):
text = tbuffer.get_text(tbuffer.get_start_iter(),
tbuffer.get_end_iter(), True)
self._active_recd.setTags(text)
def _toggle_fullscreen(self):
# logger.debug('_toggle_fullscreen')
self._fullscreen = not self._fullscreen
if not self._active_recd:
self.model.glive.stop()
if self._fullscreen:
self.get_toolbar_box().hide()
self._thumb_tray.hide()
if self._active_recd:
self._controls_hbox.hide()
else:
self.get_toolbar_box().show()
self._thumb_tray.show()
self._controls_hbox.show()
self._media_view.set_fullscreen(self._fullscreen)
if self._active_recd:
return
if self.model.get_state() == constants.STATE_RECORDING:
return
# hack, reason unknown
# problem: call to self.mode.glive.play() does not show live view
# solution: defer until after VideoBox resize is complete
self._timer_hid = None
def on_timer_cb():
self.model.glive.play()
self._timer_hid = None
return False
self._timer_hid = GLib.timeout_add(1000, on_timer_cb)
def on_defer_cb():
self.model.glive.play()
if self._timer_hid:
GLib.source_remove(self._timer_hid)
self._timer_hid = None
return False
def on_event_cb(widget, event):
if event.state == Gdk.VisibilityState.UNOBSCURED:
GLib.timeout_add(30, on_defer_cb)
self._media_view._video.disconnect_by_func(on_event_cb)
self._media_view._video.add_events(
Gdk.EventMask.VISIBILITY_NOTIFY_MASK)
self._media_view._video.connect('visibility-notify-event', on_event_cb)
# FIXME: fullscreen toggle during video recording gives black
# window, TODO: do the same as above for the video recording
# pipeline when it is active
def _mode_button_clicked(self, button):
self.model.change_mode(button.mode)
def _shutter_clicked(self, arg):
self.model.do_shutter()
def set_shutter_sensitive(self, value):
self._shutter_button.set_sensitive(value)
def set_state(self, state):
radio_state = (state == constants.STATE_READY)
for item in (self._photo_button,
self._audio_button,
self._video_button):
if item:
item.set_sensitive(radio_state)
self._showing_info = False
if state == constants.STATE_READY:
if self._state == constants.STATE_PROCESSING:
self.unbusy()
self._active_recd = None
self._mirror_btn.props.sensitive = True
self._title_entry.hide()
self._title_label.hide()
self.set_title_visible(False)
self._play_button.hide()
self._playback_scale.hide()
self._progress.hide()
self._controls_hbox.set_child_packing(self._shutter_button,
expand=True, fill=False,
padding=0,
pack_type=Gtk.PackType.START)
self._shutter_button.set_normal()
self._shutter_button.set_sensitive(True)
self._shutter_button.show()
self._media_view.show_live()
elif state == constants.STATE_RECORDING:
self._mirror_btn.props.sensitive = False
self._shutter_button.set_recording()
self._controls_hbox.set_child_packing(self._shutter_button,
expand=False, fill=False,
padding=0,
pack_type=Gtk.PackType.START)
self._progress.show()
elif state == constants.STATE_PROCESSING:
self.busy()
self._shutter_button.hide()
self._progress.show()
elif state == constants.STATE_DOWNLOADING:
self._shutter_button.hide()
self._progress.show()
self._state = state
def set_paused(self, value):
if value:
self._play_button.set_play()
else:
self._play_button.set_pause()
def _thumbnail_clicked(self, button, recd):
if self.model.ui_frozen():
return
self.model.abort_countdown()
self.model.glive.stop()
self._mirror_btn.props.sensitive = False
self._active_recd = recd
self._show_recd(recd)
def add_thumbnail(self, recd):
button = RecdButton(recd)
clicked_handler = button.connect("clicked",
self._thumbnail_clicked, recd)
remove_handler = button.connect("remove-requested",
self._remove_recd)
clipboard_handler = button.connect("copy-clipboard-requested",
self._thumbnail_copy_clipboard)
button.handler_ids = (clicked_handler, remove_handler,
clipboard_handler)
button.show()
self._thumb_tray.add_item(button)
self._thumb_tray.scroll_to_item(button)
# FIXME: possible toolkit bug; scroll_to_item is ineffective,
# only noticed when the tray is full
def _copy_to_clipboard(self, recd):
if recd is None:
return
if not recd.isClipboardCopyable():
return
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
clipboard.set_image(recd.getCopyClipboardPixbuf())
def _thumbnail_copy_clipboard(self, recdbutton):
self._copy_to_clipboard(recdbutton.get_recd())
def _remove_recd(self, recdbutton):
recd = recdbutton.get_recd()
self.model.delete_recd(recd)
if self._active_recd == recd:
self.model.set_state(constants.STATE_READY)
self._remove_thumbnail(recdbutton)
def _remove_thumbnail(self, recdbutton):
for handler in recdbutton.handler_ids:
recdbutton.disconnect(handler)
self._thumb_tray.remove_item(recdbutton)
recdbutton.cleanup()
def show_still(self, pixbuf):
self._media_view.show_still(pixbuf)
def _show_photo(self, recd):
path = self._get_photo_path(recd)
self._media_view.show_photo(path)
self._title_entry.set_text(recd.title)
self._title_entry.show()
self._title_label.show()
self.set_title_visible(True)
self._shutter_button.hide()
self._progress.hide()
def _show_audio(self, recd, play):
self._progress.hide()
self._shutter_button.hide()
self._title_entry.hide()
self._title_label.hide()
self.set_title_visible(False)
self._play_button.show()
self._playback_scale.show()
path = recd.getAudioImageFilepath()
self._media_view.show_photo(path)
if play:
self.model.play_audio(recd)
def _show_video(self, recd, play):
self._progress.hide()
self._shutter_button.hide()
self._title_entry.hide()
self._title_label.hide()
self.set_title_visible(False)
self._play_button.show()
self._playback_scale.show()
self._media_view.show_video()
if play:
self.model.play_video(recd)
def set_playback_scale(self, value):
self._playback_scale.set_value(value)
def _get_photo_path(self, recd):
# FIXME should live (partially) in recd?
# downloading = self.ca.requestMeshDownload(recd)
# self.MESHING = downloading
if True: # not downloading:
# self.progressWindow.updateProgress(0, "")
return recd.getMediaFilepath()
# maybe it is not downloaded from the mesh yet...
# but we can show the low res thumb in the interim
return recd.getThumbFilepath()
def _show_recd(self, recd, play=True):
self._showing_info = False
if recd.buddy and not recd.downloadedFromBuddy:
self.model.request_download(recd)
elif recd.type == constants.TYPE_PHOTO:
self._show_photo(recd)
elif recd.type == constants.TYPE_AUDIO:
self._show_audio(recd, play)
elif recd.type == constants.TYPE_VIDEO:
self._show_video(recd, play)
def remote_recd_available(self, recd):
self.model.set_state(constants.STATE_INVISIBLE)
if recd == self._active_recd:
self._show_recd(recd)
def update_download_progress(self, recd):
if recd != self._active_recd:
return
if not recd.meshDownloading:
msg = _('Download failed.')
elif recd.meshDownloadingProgress:
msg = _('Downloading...')
else:
msg = _('Requesting...')
self.set_progress(recd.meshDownlodingPercent, msg)
class MusicpainterActivity(activity.Activity):
def __init__(self, handle):
self.to_read = ''
self.btn_added = False
activity.Activity.__init__(self, handle)
self.max_participants = 1
self.connect('destroy', self._cleanup_cb)
#load the sugar toolbar
self.toolbar_box = ToolbarBox()
self.activity_btn = ActivityToolbarButton(self)
self.activity_btn.connect('clicked', self.to_detail_mode)
self.new_file_btn = ToolButton('file_new')
self.new_file_btn.set_tooltip('New')
self.new_file_btn.connect('clicked', self.new_file)
self.save_file_btn = ToolButton('file_save')
self.save_file_btn.set_tooltip('Save')
self.save_file_btn.connect('clicked', self.save_file)
self.save_file_as_btn = ToolButton('file_save_as')
self.save_file_as_btn.set_tooltip('Save As')
self.save_file_as_btn.connect('clicked', self.save_file_as)
self.share_file_btn = ToolButton('file_upload')
self.share_file_btn.set_tooltip('Share')
self.share_file_btn.connect('clicked', self.share_file)
separator = Gtk.SeparatorToolItem()
separator.show()
toolbar = self.activity_btn.props.page
self.title_box = toolbar.get_nth_item(0)
self.desc_btn = toolbar.get_nth_item(1)
toolbar.insert(separator, 2)
toolbar.insert(self.new_file_btn, -1)
toolbar.insert(self.save_file_btn, -1)
toolbar.insert(self.save_file_as_btn, -1)
toolbar.insert(self.share_file_btn, -1)
self.toolbar_box.toolbar.insert(self.activity_btn, 0)
self.toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), 1)
self.home_btn = RadioToolButton()
self.home_btn.set_tooltip('Home')
self.home_btn.props.icon_name = 'toolbox_home'
self.home_btn.props.group = self.home_btn
self.home_btn.connect('clicked', self.go_home)
self.toolbar_box.toolbar.insert(self.home_btn, 2)
self.canvas_mode_btn = RadioToolButton()
self.canvas_mode_btn.set_tooltip('Canvas')
self.canvas_mode_btn.props.icon_name = 'toolbox_canvas'
self.canvas_mode_btn.props.group = self.home_btn
self.canvas_mode_btn.connect('clicked', self.to_canvas_mode)
self.toolbar_box.toolbar.insert(self.canvas_mode_btn, 3)
self.keyboard_mode_btn = RadioToolButton()
self.keyboard_mode_btn.set_tooltip('Keyboard')
self.keyboard_mode_btn.props.icon_name = 'toolbox_keyboard'
self.keyboard_mode_btn.props.group = self.home_btn
self.keyboard_mode_btn.connect('clicked', self.to_keyboard_mode)
self.toolbar_box.toolbar.insert(self.keyboard_mode_btn, 4)
self.configure_ins_btn = RadioToolButton()
self.configure_ins_btn.set_tooltip('Select instruments')
self.configure_ins_btn.props.icon_name = 'toolbox_instrument'
self.configure_ins_btn.props.group = self.home_btn
self.configure_ins_btn.connect('clicked', self.configure_ins)
self.toolbar_box.toolbar.insert(self.configure_ins_btn, 5)
self.seperator = Gtk.SeparatorToolItem()
#self.toolbar_box.toolbar.insert(self.seperator, 6)
self.configure_scale_btn = ToggleToolButton()
self.configure_scale_btn.set_tooltip('Select scale')
self.configure_scale_btn.props.icon_name = 'toolbox_scale'
self.configure_scale_btn.connect('toggled', self.choose_scale)
#self.toolbar_box.toolbar.insert(self.configure_scale_btn, 7)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar_box.toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
self.toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(self.toolbar_box)
self.toolbar_box.show_all()
#self.set_toolbox(toolbox)
#activity_toolbar = toolbox.get_activity_toolbar()
#activity_toolbar.remove(activity_toolbar.share)
#activity_toolbar.share = None
#activity_toolbar.keep.connect('clicked', self._keep_cb)
#activity_toolbar.stop.can_focus = True
#activity_toolbar.keep.can_focus = True
#toolbox.show()
#activity_toolbar.keep.grab_focus()
self.gamename = 'Musicpainter'
self.set_title("Music Painter")
## connect to the in/out events
#self.connect('notify::active', self.onActive)
#self.connect('focus_in_event', self._focus_in)
#self.connect('focus_out_event', self._focus_out)
self.musicpainter = Musicpainter.Musicpainter()
presenceService = presenceservice.get_instance()
xoOwner = presenceService.get_owner() # get my name
self.musicpainter.initSugar(self, xoOwner.props.nick)
if not (self.to_read == '' or self.uid == ''):
#try:
print "Read journal uid: (" + self.uid + "), filename: " + self.to_read
self.musicpainter.score.read_journal(self.to_read, self.uid)
#except:
#print "Exception caught when reading journal."
#try:
print "Init view: " + self.metadata['view']
self.musicpainter.init_view(self.metadata['view'])
self.init_view_sugar(self.metadata['view'])
#except:
#print "No initial view."
else:
self.musicpainter.score.new_score() # init a canvas
#self.musicpainter.init_view('canvas')
#self.init_view_sugar('canvas')
self.musicpainter.init_view('home')
self.init_view_sugar('home')
#self.create_journal()
#bus = dbus.SessionBus()
#remote_object = bus.get_object(DS_DBUS_SERVICE, DS_DBUS_PATH)
#_datastore = dbus.Interface(remote_object, DS_DBUS_INTERFACE)
#_datastore.connect_to_signal('Created', self.datastore_created_cb)
#_datastore.connect_to_signal('Updated', self.datastore_updated_cb)
#_datastore.connect_to_signal('Deleted', self.datastore_deleted_cb)
def new_file(self, widget):
self.musicpainter.score.new_score()
self.to_canvas_mode(widget)
self.activity_btn.set_expanded(False)
self.toolbar_changed(widget)
def msg_box_callback(self):
self.to_canvas_mode(self.w)
#self.activity_btn.set_expanded(False)
#self.toolbar_changed(self.w)
def upload_callback(self):
self.musicpainter.detail_view.show_message_box("Upload successful! ")
def save_file(self, widget):
if self.musicpainter.current_view != 'detail':
self.to_detail_mode(widget)
self.musicpainter.detail_view.set_toolbar_expanded(
self.musicpainter.toolbar_expanded)
if self.musicpainter.score.save_score():
self.w = widget
self.musicpainter.detail_view.show_message_box("Save successful!")
def save_file_as(self, widget):
if self.musicpainter.current_view != 'detail':
self.to_detail_mode(widget)
self.musicpainter.detail_view.set_toolbar_expanded(
self.musicpainter.toolbar_expanded)
if self.musicpainter.score.save_score_as():
self.w = widget
self.musicpainter.detail_view.show_message_box("Save successful!")
def share_file(self, widget):
if self.musicpainter.current_view != 'detail':
self.to_detail_mode(widget)
self.musicpainter.detail_view.set_toolbar_expanded(
self.musicpainter.toolbar_expanded)
if not self.musicpainter.score.upload_eligible():
self.w = widget
self.musicpainter.detail_view.show_message_box(
"Please make changes before upload. ")
else:
self.w = widget
self.musicpainter.score.save_score()
self.musicpainter.network.upload_music(
self.musicpainter.score.uid + ".png")
def toolbar_changed(self, widget):
#print "activity.toolbar_changed()"
self.musicpainter.toolbar_switch()
def go_home(self, widget):
self.musicpainter.go_home()
self.hide_scale_btn()
if self.musicpainter.toolbar_expanded:
self.activity_btn.set_expanded(False)
self.toolbar_changed(widget)
def to_detail_mode(self, widget):
if self.musicpainter.to_detail_mode_from_sugar():
self.show_scale_btn()
else:
self.hide_scale_btn()
def to_canvas_mode(self, widget):
self.musicpainter.to_canvas_view()
self.show_scale_btn()
if self.musicpainter.toolbar_expanded:
self.activity_btn.set_expanded(False)
self.toolbar_changed(widget)
def to_keyboard_mode(self, widget):
self.musicpainter.to_keyboard_mode()
self.show_scale_btn()
if self.musicpainter.toolbar_expanded:
self.activity_btn.set_expanded(False)
self.toolbar_changed(widget)
def configure_ins(self, widget):
self.musicpainter.to_instrument_view()
self.hide_scale_btn()
if self.musicpainter.toolbar_expanded:
self.activity_btn.set_expanded(False)
self.toolbar_changed(widget)
def choose_scale(self, widget):
self.musicpainter.choose_scale()
def hide_scale_btn(self):
if self.btn_added:
self.seperator.set_visible(False)
self.configure_scale_btn.set_visible(False)
def show_scale_btn(self):
if not self.btn_added:
self.toolbar_box.toolbar.insert(self.seperator, 6)
self.toolbar_box.toolbar.insert(self.configure_scale_btn, 7)
self.toolbar_box.show_all()
self.btn_added = True
else:
self.seperator.set_visible(True)
self.configure_scale_btn.set_visible(True)
def set_active_btn(self, mode):
if mode == 'canvas':
self.canvas_mode_btn.set_active(True)
elif mode == 'keyboard':
self.keyboard_mode_btn.set_active(True)
elif mode == 'instruments':
self.configure_ins_btn.set_active(True)
def set_scale(self, flag):
self.configure_scale_btn.set_active(flag)
def hide_scale_btn(self):
self.seperator.set_visible(False)
self.configure_scale_btn.set_visible(False)
def _keep_cb(self, data=None):
#print "to keep()"
#self.musicpainter.canvas.save_file()
return
def _cleanup_cb(self, data=None):
return
def _focus_in(self, event, data=None):
return
def _focus_out(self, event, data=None):
return
def onActive(self, widget=None, event=None):
#if widget.props.active == False:
# print "MusicpainterActivity.onActive: to disconnect"
# self.musicpainter.deactivate()
##else:
# #print "MusicpainterActivity.onActive: to re-connect"
# #self.musicpainter.reactivate()
return
def read_file(self, file_path):
#'''Read file from Sugar Journal.'''
#print "read file: " + file_path + " pending"
self.to_read = file_path
self.uid = self.metadata['uid']
#print self.metadata.keys()
return
#def create_journal(self):
#file_path = 'temp.mpn'
#journal_entry = datastore.create()
#try:
#print "new entry uid after create: " + str(journal_entry.metadata['uid'])
#except:
#print "no uid"
#journal_entry.metadata['title'] = 'create journal test'
#journal_entry.file_path = file_path
#self.musicpainter.score.write_journal(file_path)
#datastore.write(journal_entry)
#os.remove(file_path)
#print "journal created"
#try:
#print "new entry uid: " + str(journal_entry.metadata['uid'])
#except:
#print "no uid"
#def create_journal(self):
#print 'create_journal()'
#journal_entry = datastore.create()
#journal_entry.metadata['activity'] = self.get_bundle_id()
#journal_entry.metadata['mime_type'] = 'application/x-musicpainter'
#datastore.write(journal_entry)
def update_uid(self,
uid): # actually, this is meant to screw up the original id
#self.metadata['uid'] = uid
self._jobject.object_id = uid
def update_title(self, title):
self.metadata['title'] = title
self.title_box.entry.set_text(title)
def get_description(self):
try:
return self.metadata['description']
except:
return
def write_file(self, file_path):
#'''Save file on Sugar Journal. '''
print "write journal: " + file_path
#print "uid = " + self.metadata['uid']
#if self._jobject.object_id == None or self.metadata['uid'] == None:
#print 'no uid yet'
uid = self.musicpainter.score.uid
#uid = self.metadata['uid']
#else:
#print "wait for uid"
#return
self.musicpainter.score.title = self.metadata['title']
try:
self.musicpainter.score.description = self.metadata['description']
except:
print "no description"
self.musicpainter.score.write_journal(file_path, uid)
#self.musicpainter.score.write_journal(file_path, self._jobject.object_id)
self.metadata['activity'] = self.get_bundle_id()
self.metadata['mime_type'] = 'activity-musicpainter'
self.metadata['view'] = self.musicpainter.get_current_view()
def init_view_sugar(self, view):
if view == 'canvas':
self.toolbar_box.toolbar.insert(self.seperator, 6)
self.toolbar_box.toolbar.insert(self.configure_scale_btn, 7)
self.toolbar_box.show_all()
self.btn_added = True
elif view == 'keyboard':
self.toolbar_box.toolbar.insert(self.seperator, 6)
self.toolbar_box.toolbar.insert(self.configure_scale_btn, 7)
self.toolbar_box.show_all()
self.btn_added = True
self.set_active_btn(view)
class JukeboxActivity(activity.Activity):
__gsignals__ = {
'playlist-finished': (GObject.SignalFlags.RUN_FIRST, None, []), }
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.player = None
self._alert = None
self._playlist_jobject = None
self._on_unfullscreen_show_playlist = False
self.set_title(_('Jukebox Activity'))
self.max_participants = 1
toolbar_box = ToolbarBox()
self._activity_toolbar_button = ActivityToolbarButton(self)
activity_toolbar = self._activity_toolbar_button.page
toolbar_box.toolbar.insert(self._activity_toolbar_button, 0)
self.title_entry = activity_toolbar.title
self._view_toolbar = ViewToolbar()
self._view_toolbar.connect('go-fullscreen',
self.__go_fullscreen_cb)
self._view_toolbar.connect('toggle-playlist',
self.__toggle_playlist_cb)
view_toolbar_button = ToolbarButton(
page=self._view_toolbar,
icon_name='toolbar-view')
self._view_toolbar.show()
toolbar_box.toolbar.insert(view_toolbar_button, -1)
view_toolbar_button.show()
self._control_toolbar = Gtk.Toolbar()
self._control_toolbar_button = ToolbarButton(
page=self._control_toolbar,
icon_name='media-playback-start')
self._control_toolbar.show()
toolbar_box.toolbar.insert(self._control_toolbar_button, -1)
self._control_toolbar_button.hide()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.connect('key_press_event', self.__key_press_event_cb)
self.connect('playlist-finished', self.__playlist_finished_cb)
# We want to be notified when the activity gets the focus or
# loses it. When it is not active, we don't need to keep
# reproducing the video
self.connect('notify::active', self.__notify_active_cb)
self._video_canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self._playlist_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.playlist_widget = PlayList()
self.playlist_widget.connect('play-index', self.__play_index_cb)
self.playlist_widget.connect('missing-tracks',
self.__missing_tracks_cb)
self.playlist_widget.set_size_request(
Gdk.Screen.width() * PLAYLIST_WIDTH_PROP, 0)
self.playlist_widget.show()
self._playlist_box.pack_start(self.playlist_widget, expand=True,
fill=True, padding=0)
self._playlist_toolbar = Gtk.Toolbar()
move_up = ToolButton("go-up")
move_up.set_tooltip(_("Move up"))
move_up.connect("clicked", self._move_up_cb)
self._playlist_toolbar.insert(move_up, 0)
move_down = ToolButton("go-down")
move_down.set_tooltip(_("Move down"))
move_down.connect("clicked", self._move_down_cb)
self._playlist_toolbar.insert(move_down, 1)
self._playlist_box.pack_end(self._playlist_toolbar, False, False, 0)
self._video_canvas.pack_start(self._playlist_box, False, False, 0)
# Create the player just once
logging.debug('Instantiating GstPlayer')
self.player = GstPlayer()
self.player.connect('eos', self.__player_eos_cb)
self.player.connect('error', self.__player_error_cb)
self.player.connect('play', self.__player_play_cb)
self.control = Controls(self, toolbar_box.toolbar,
self._control_toolbar)
self._separator = Gtk.SeparatorToolItem()
self._separator.props.draw = False
self._separator.set_expand(True)
self._separator.show()
toolbar_box.toolbar.insert(self._separator, -1)
self._stop = StopButton(self)
toolbar_box.toolbar.insert(self._stop, -1)
self._empty_widget = Gtk.Label(label="")
self._empty_widget.show()
self.videowidget = VideoWidget()
self.set_canvas(self._video_canvas)
self._init_view_area()
self.show_all()
if len(self.playlist_widget) < 2:
self._view_toolbar._show_playlist.props.active = False
self._configure_cb()
self.player.init_view_area(self.videowidget)
self._volume_monitor = Gio.VolumeMonitor.get()
self._volume_monitor.connect('mount-added', self.__mount_added_cb)
self._volume_monitor.connect('mount-removed', self.__mount_removed_cb)
if handle.object_id is None:
# The activity was launched from scratch. We need to show
# the Empty Widget
self.playlist_widget.hide()
emptypanel.show(self, 'activity-jukebox',
_('No media'), _('Choose media files'),
self.control.show_picker_cb)
self.control.check_if_next_prev()
Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
def _move_up_cb(self, button):
self.playlist_widget.move_up()
def _move_down_cb(self, button):
self.playlist_widget.move_down()
def _configure_cb(self, event=None):
toolbar = self.get_toolbar_box().toolbar
toolbar.remove(self._stop)
toolbar.remove(self._separator)
if Gdk.Screen.width() < Gdk.Screen.height():
self._control_toolbar_button.show()
self._control_toolbar_button.set_expanded(True)
self.control.update_layout(landscape=False)
toolbar.insert(self._separator, -1)
else:
self._control_toolbar_button.set_expanded(False)
self._control_toolbar_button.hide()
self.control.update_layout(landscape=True)
toolbar.insert(self._stop, -1)
def __notify_active_cb(self, widget, event):
"""Sugar notify us that the activity is becoming active or inactive.
When we are inactive, we stop the player if it is reproducing
a video.
"""
logging.debug('JukeboxActivity notify::active signal received')
if self.player.player.props.current_uri is not None and \
self.player.playing_video():
if not self.player.is_playing() and self.props.active:
self.player.play()
if self.player.is_playing() and not self.props.active:
self.player.pause()
def _init_view_area(self):
"""
Use a notebook with two pages, one empty an another
with the videowidget
"""
self.view_area = Gtk.Notebook()
self.view_area.set_show_tabs(False)
self.view_area.append_page(self._empty_widget, None)
self.view_area.append_page(self.videowidget, None)
self._video_canvas.pack_end(self.view_area, expand=True,
fill=True, padding=0)
def _switch_canvas(self, show_video):
"""Show or hide the video visualization in the canvas.
When hidden, the canvas is filled with an empty widget to
ensure redrawing.
"""
if show_video:
self.view_area.set_current_page(1)
else:
self.view_area.set_current_page(0)
self._video_canvas.queue_draw()
def __key_press_event_cb(self, widget, event):
key = event.keyval
ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
# while activity toolbar is visible, only escape key is taken
if self._activity_toolbar_button.is_expanded():
if key == Gdk.KEY_Escape:
self._activity_toolbar_button.set_expanded(False)
return True
return False
# while title is focused, no shortcuts
if self.title_entry.has_focus():
return False
# Shortcut - Space does play or pause
if key == Gdk.KEY_space:
self.control.button.emit('clicked')
return True
# Shortcut - Up does previous playlist item
if key == Gdk.KEY_Up:
self.control.prev_button.emit('clicked')
return True
# Shortcut - Down does next playlist item
if key == Gdk.KEY_Down:
self.control.next_button.emit('clicked')
return True
# Shortcut - Escape does unfullscreen, then playlist hide
if key == Gdk.KEY_Escape:
if self.is_fullscreen():
# sugar3.graphics.Window.__key_press_cb will handle it
return False
if self._view_toolbar._show_playlist.props.active:
self._view_toolbar._show_playlist.props.active = False
return True
# Shortcut - ctrl-f does fullscreen toggle
# (fullscreen enable is handled by ToolButton accelerator)
if ctrl and key == Gdk.KEY_f:
if self.is_fullscreen():
self.unfullscreen()
return True
# Shortcut - ctrl-l does playlist toggle
# (ToggleToolButton accelerator ineffective when ViewToolbar hidden)
if ctrl and key == Gdk.KEY_l:
togglebutton = self._view_toolbar._show_playlist
togglebutton.props.active = not togglebutton.props.active
return True
return False
def __playlist_finished_cb(self, widget):
self._switch_canvas(show_video=False)
self._view_toolbar._show_playlist.props.active = True
self.unfullscreen()
# Select the first stream to be played when Play button will
# be pressed
self.playlist_widget.set_current_playing(0)
self.control.check_if_next_prev()
def songchange(self, direction):
current_playing = self.playlist_widget.get_current_playing()
if direction == 'prev' and current_playing > 0:
self.play_index(current_playing - 1)
elif direction == 'next' and \
current_playing < len(self.playlist_widget._items) - 1:
self.play_index(current_playing + 1)
else:
self.emit('playlist-finished')
def play_index(self, index):
# README: this line is no more necessary because of the
# .playing_video() method
# self._switch_canvas(show_video=True)
self.playlist_widget.set_current_playing(index)
path = self.playlist_widget._items[index]['path']
if self.playlist_widget.check_available_media(path):
if self.playlist_widget.is_from_journal(path):
path = self.playlist_widget.get_path_from_journal(path)
self.control.check_if_next_prev()
self.player.set_uri(path)
self.player.play()
else:
self.songchange('next')
def __play_index_cb(self, widget, index, path):
# README: this line is no more necessary because of the
# .playing_video() method
# self._switch_canvas(show_video=True)
self.playlist_widget.set_current_playing(index)
if self.playlist_widget.is_from_journal(path):
path = self.playlist_widget.get_path_from_journal(path)
self.control.check_if_next_prev()
self.player.set_uri(path)
self.player.play()
def __player_eos_cb(self, widget):
self.songchange('next')
def _show_error_alert(self, title, msg=None):
self._alert = ErrorAlert()
self._alert.props.title = title
if msg is not None:
self._alert.props.msg = msg
self.add_alert(self._alert)
self._alert.connect('response', self._alert_cancel_cb)
self._alert.show()
def __mount_added_cb(self, volume_monitor, device):
logging.debug('Mountpoint added. Checking...')
self.remove_alert(self._alert)
self.playlist_widget.update()
def __mount_removed_cb(self, volume_monitor, device):
logging.debug('Mountpoint removed. Checking...')
self.remove_alert(self._alert)
self.playlist_widget.update()
def __missing_tracks_cb(self, widget, tracks):
self._show_missing_tracks_alert(tracks)
def _show_missing_tracks_alert(self, tracks):
self._alert = Alert()
title = _('%s tracks not found.') % len(tracks)
self._alert.props.title = title
icon = Icon(icon_name='dialog-cancel')
self._alert.add_button(Gtk.ResponseType.CANCEL, _('Dismiss'), icon)
icon.show()
icon = Icon(icon_name='dialog-ok')
self._alert.add_button(Gtk.ResponseType.APPLY, _('Details'), icon)
icon.show()
self.add_alert(self._alert)
self._alert.connect(
'response', self.__missing_tracks_alert_response_cb, tracks)
def __missing_tracks_alert_response_cb(self, alert, response_id, tracks):
if response_id == Gtk.ResponseType.APPLY:
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.props.valign = Gtk.Align.CENTER
label = Gtk.Label(label='')
label.set_markup(_('<b>Missing tracks</b>'))
vbox.pack_start(label, False, False, 15)
for track in tracks:
label = Gtk.Label(label=track['path'])
vbox.add(label)
_missing_tracks = Gtk.ScrolledWindow()
_missing_tracks.add_with_viewport(vbox)
_missing_tracks.show_all()
self.view_area.append_page(_missing_tracks, None)
self.view_area.set_current_page(2)
self.remove_alert(alert)
def _alert_cancel_cb(self, alert, response_id):
self.remove_alert(alert)
def __player_play_cb(self, widget):
self._switch_canvas(True)
def __player_error_cb(self, widget, message, detail):
self.player.stop()
self.control.set_disabled()
logging.error('ERROR MESSAGE: %s', message)
logging.error('ERROR DETAIL: %s', detail)
file_path = self.playlist_widget._items[
self.playlist_widget.get_current_playing()]['path']
mimetype = mime.get_for_file(file_path)
title = _('Error')
msg = _('This "%s" file can\'t be played') % mimetype
self._switch_canvas(False)
self._show_error_alert(title, msg)
def can_close(self):
# We need to put the Gst.State in NULL so gstreamer can
# cleanup the pipeline
self.player.stop()
return True
def read_file(self, file_path):
"""Load a file from the datastore on activity start."""
logging.debug('JukeboxActivity.read_file: %s', file_path)
title = self.metadata['title']
self.playlist_widget.load_file(file_path, title)
def write_file(self, file_path):
def write_playlist_to_file(file_path):
"""Open the file at file_path and write the playlist.
It is saved in audio/x-mpegurl format.
"""
list_file = open(file_path, 'w')
for uri in self.playlist_widget._items:
list_file.write('#EXTINF:%s\n' % uri['title'])
list_file.write('%s\n' % uri['path'])
list_file.close()
if not self.metadata['mime_type']:
self.metadata['mime_type'] = 'audio/x-mpegurl'
if self.metadata['mime_type'] == 'audio/x-mpegurl':
write_playlist_to_file(file_path)
else:
if self._playlist_jobject is None:
self._playlist_jobject = \
self.playlist_widget.create_playlist_jobject()
# Add the playlist to the playlist jobject description.
# This is only done if the activity was not started from a
# playlist or from scratch:
description = ''
for uri in self.playlist_widget._items:
description += '%s\n' % uri['title']
self._playlist_jobject.metadata['description'] = description
write_playlist_to_file(self._playlist_jobject.file_path)
datastore.write(self._playlist_jobject)
def unfullscreen(self):
activity.Activity.unfullscreen(self)
if self._on_unfullscreen_show_playlist:
self._view_toolbar._show_playlist.props.active = True
def __go_fullscreen_cb(self, toolbar):
if self._view_toolbar._show_playlist.props.active:
self._view_toolbar._show_playlist.props.active = False
self._on_unfullscreen_show_playlist = True
self.fullscreen()
def __toggle_playlist_cb(self, toolbar):
if self._view_toolbar._show_playlist.props.active:
self._playlist_box.show_all()
else:
self._playlist_box.hide()
self._video_canvas.queue_draw()
class JukeboxActivity(activity.Activity):
__gsignals__ = {
'playlist-finished': (GObject.SignalFlags.RUN_FIRST, None, []), }
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.player = None
self._alert = None
self._playlist_jobject = None
self._on_unfullscreen_show_playlist = False
self.set_title(_('Jukebox Activity'))
self.max_participants = 1
toolbar_box = ToolbarBox()
self._activity_toolbar_button = ActivityToolbarButton(self)
activity_toolbar = self._activity_toolbar_button.page
toolbar_box.toolbar.insert(self._activity_toolbar_button, 0)
self.title_entry = activity_toolbar.title
self._view_toolbar = ViewToolbar()
self._view_toolbar.connect('go-fullscreen',
self.__go_fullscreen_cb)
self._view_toolbar.connect('toggle-playlist',
self.__toggle_playlist_cb)
view_toolbar_button = ToolbarButton(
page=self._view_toolbar,
icon_name='toolbar-view')
self._view_toolbar.show()
toolbar_box.toolbar.insert(view_toolbar_button, -1)
view_toolbar_button.show()
self._control_toolbar = Gtk.Toolbar()
self._control_toolbar_button = ToolbarButton(
page=self._control_toolbar,
icon_name='media-playback-start')
self._control_toolbar.show()
toolbar_box.toolbar.insert(self._control_toolbar_button, -1)
self._control_toolbar_button.hide()
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self.connect('key_press_event', self.__key_press_event_cb)
self.connect('playlist-finished', self.__playlist_finished_cb)
# We want to be notified when the activity gets the focus or
# loses it. When it is not active, we don't need to keep
# reproducing the video
self.connect('notify::active', self.__notify_active_cb)
self._video_canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self._playlist_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.playlist_widget = PlayList()
self.playlist_widget.connect('play-index', self.__play_index_cb)
self.playlist_widget.connect('missing-tracks',
self.__missing_tracks_cb)
self.playlist_widget.set_size_request(
Gdk.Screen.width() * PLAYLIST_WIDTH_PROP, 0)
self.playlist_widget.show()
self._playlist_box.pack_start(self.playlist_widget, expand=True,
fill=True, padding=0)
self._playlist_toolbar = Gtk.Toolbar()
move_up = ToolButton("go-up")
move_up.set_tooltip(_("Move up"))
move_up.connect("clicked", self._move_up_cb)
self._playlist_toolbar.insert(move_up, 0)
move_down = ToolButton("go-down")
move_down.set_tooltip(_("Move down"))
move_down.connect("clicked", self._move_down_cb)
self._playlist_toolbar.insert(move_down, 1)
self._playlist_box.pack_end(self._playlist_toolbar, False, False, 0)
self._video_canvas.pack_start(self._playlist_box, False, False, 0)
# Create the player just once
logging.debug('Instantiating GstPlayer')
self.player = GstPlayer()
self.player.connect('eos', self.__player_eos_cb)
self.player.connect('error', self.__player_error_cb)
self.player.connect('play', self.__player_play_cb)
self.control = Controls(self, toolbar_box.toolbar,
self._control_toolbar)
self._separator = Gtk.SeparatorToolItem()
self._separator.props.draw = False
self._separator.set_expand(True)
self._separator.show()
toolbar_box.toolbar.insert(self._separator, -1)
self._stop = StopButton(self)
toolbar_box.toolbar.insert(self._stop, -1)
self._empty_widget = Gtk.Label(label="")
self._empty_widget.show()
self.videowidget = VideoWidget()
self.set_canvas(self._video_canvas)
self._init_view_area()
self.show_all()
if len(self.playlist_widget) < 2:
self._view_toolbar._show_playlist.props.active = False
self._configure_cb()
self.player.init_view_area(self.videowidget)
self._volume_monitor = Gio.VolumeMonitor.get()
self._volume_monitor.connect('mount-added', self.__mount_added_cb)
self._volume_monitor.connect('mount-removed', self.__mount_removed_cb)
if handle.object_id is None:
# The activity was launched from scratch. We need to show
# the Empty Widget
self.playlist_widget.hide()
emptypanel.show(self, 'activity-jukebox',
_('No media'), _('Choose media files'),
self.control.show_picker_cb)
self.control.check_if_next_prev()
Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
def _move_up_cb(self, button):
self.playlist_widget.move_up()
def _move_down_cb(self, button):
self.playlist_widget.move_down()
def _configure_cb(self, event=None):
toolbar = self.get_toolbar_box().toolbar
toolbar.remove(self._stop)
toolbar.remove(self._separator)
if Gdk.Screen.width() < Gdk.Screen.height():
self._control_toolbar_button.show()
self._control_toolbar_button.set_expanded(True)
self.control.update_layout(landscape=False)
toolbar.insert(self._separator, -1)
else:
self._control_toolbar_button.set_expanded(False)
self._control_toolbar_button.hide()
self.control.update_layout(landscape=True)
toolbar.insert(self._stop, -1)
def __notify_active_cb(self, widget, event):
"""Sugar notify us that the activity is becoming active or inactive.
When we are inactive, we stop the player if it is reproducing
a video.
"""
logging.debug('JukeboxActivity notify::active signal received')
if self.player.player.props.current_uri is not None and \
self.player.playing_video():
if not self.player.is_playing() and self.props.active:
self.player.play()
if self.player.is_playing() and not self.props.active:
self.player.pause()
def _init_view_area(self):
"""
Use a notebook with two pages, one empty an another
with the videowidget
"""
self.view_area = Gtk.Notebook()
self.view_area.set_show_tabs(False)
self.view_area.append_page(self._empty_widget, None)
self.view_area.append_page(self.videowidget, None)
self._video_canvas.pack_end(self.view_area, expand=True,
fill=True, padding=0)
def _switch_canvas(self, show_video):
"""Show or hide the video visualization in the canvas.
When hidden, the canvas is filled with an empty widget to
ensure redrawing.
"""
if show_video:
self.view_area.set_current_page(1)
else:
self.view_area.set_current_page(0)
self._video_canvas.queue_draw()
def __key_press_event_cb(self, widget, event):
key = event.keyval
ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
# while activity toolbar is visible, only escape key is taken
if self._activity_toolbar_button.is_expanded():
if key == Gdk.KEY_Escape:
self._activity_toolbar_button.set_expanded(False)
return True
return False
# while title is focused, no shortcuts
if self.title_entry.has_focus():
return False
# Shortcut - Space does play or pause
if key == Gdk.KEY_space:
self.control.button.emit('clicked')
return True
# Shortcut - Up does previous playlist item
if key == Gdk.KEY_Up:
self.control.prev_button.emit('clicked')
return True
# Shortcut - Down does next playlist item
if key == Gdk.KEY_Down:
self.control.next_button.emit('clicked')
return True
# Shortcut - Escape does unfullscreen, then playlist hide
if key == Gdk.KEY_Escape:
if self.is_fullscreen():
# sugar3.graphics.Window.__key_press_cb will handle it
return False
if self._view_toolbar._show_playlist.props.active:
self._view_toolbar._show_playlist.props.active = False
return True
# Shortcut - ctrl-f does fullscreen toggle
# (fullscreen enable is handled by ToolButton accelerator)
if ctrl and key == Gdk.KEY_f:
if self.is_fullscreen():
self.unfullscreen()
return True
# Shortcut - ctrl-l does playlist toggle
# (ToggleToolButton accelerator ineffective when ViewToolbar hidden)
if ctrl and key == Gdk.KEY_l:
togglebutton = self._view_toolbar._show_playlist
togglebutton.props.active = not togglebutton.props.active
return True
return False
def __playlist_finished_cb(self, widget):
self._switch_canvas(show_video=False)
self._view_toolbar._show_playlist.props.active = True
self.unfullscreen()
# Select the first stream to be played when Play button will
# be pressed
self.playlist_widget.set_current_playing(0)
self.control.check_if_next_prev()
def songchange(self, direction):
current_playing = self.playlist_widget.get_current_playing()
if direction == 'prev' and current_playing > 0:
self.play_index(current_playing - 1)
elif direction == 'next' and \
current_playing < len(self.playlist_widget._items) - 1:
self.play_index(current_playing + 1)
else:
self.emit('playlist-finished')
def play_index(self, index):
# README: this line is no more necessary because of the
# .playing_video() method
# self._switch_canvas(show_video=True)
self.playlist_widget.set_current_playing(index)
path = self.playlist_widget._items[index]['path']
if self.playlist_widget.check_available_media(path):
if self.playlist_widget.is_from_journal(path):
path = self.playlist_widget.get_path_from_journal(path)
self.control.check_if_next_prev()
self.player.set_uri(path)
self.player.play()
else:
self.songchange('next')
def __play_index_cb(self, widget, index, path):
# README: this line is no more necessary because of the
# .playing_video() method
# self._switch_canvas(show_video=True)
self.playlist_widget.set_current_playing(index)
if self.playlist_widget.is_from_journal(path):
path = self.playlist_widget.get_path_from_journal(path)
self.control.check_if_next_prev()
self.player.set_uri(path)
self.player.play()
def __player_eos_cb(self, widget):
self.songchange('next')
def _show_error_alert(self, title, msg=None):
self._alert = ErrorAlert()
self._alert.props.title = title
if msg is not None:
self._alert.props.msg = msg
self.add_alert(self._alert)
self._alert.connect('response', self._alert_cancel_cb)
self._alert.show()
def __mount_added_cb(self, volume_monitor, device):
logging.debug('Mountpoint added. Checking...')
self.remove_alert(self._alert)
self.playlist_widget.update()
def __mount_removed_cb(self, volume_monitor, device):
logging.debug('Mountpoint removed. Checking...')
self.remove_alert(self._alert)
self.playlist_widget.update()
def __missing_tracks_cb(self, widget, tracks):
self._show_missing_tracks_alert(tracks)
def _show_missing_tracks_alert(self, tracks):
self._alert = Alert()
title = _('%s tracks not found.') % len(tracks)
self._alert.props.title = title
icon = Icon(icon_name='dialog-cancel')
self._alert.add_button(Gtk.ResponseType.CANCEL, _('Dismiss'), icon)
icon.show()
icon = Icon(icon_name='dialog-ok')
self._alert.add_button(Gtk.ResponseType.APPLY, _('Details'), icon)
icon.show()
self.add_alert(self._alert)
self._alert.connect(
'response', self.__missing_tracks_alert_response_cb, tracks)
def __missing_tracks_alert_response_cb(self, alert, response_id, tracks):
if response_id == Gtk.ResponseType.APPLY:
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.props.valign = Gtk.Align.CENTER
label = Gtk.Label(label='')
label.set_markup(_('<b>Missing tracks</b>'))
vbox.pack_start(label, False, False, 15)
for track in tracks:
label = Gtk.Label(label=track['path'])
vbox.add(label)
_missing_tracks = Gtk.ScrolledWindow()
_missing_tracks.add_with_viewport(vbox)
_missing_tracks.show_all()
self.view_area.append_page(_missing_tracks, None)
self.view_area.set_current_page(2)
self.remove_alert(alert)
def _alert_cancel_cb(self, alert, response_id):
self.remove_alert(alert)
def __player_play_cb(self, widget):
# Do not show the visualization widget if we are playing just
# an audio stream
def callback():
if self.player.playing_video():
self._switch_canvas(True)
else:
self._switch_canvas(False)
return False
# HACK: we need a timeout here because gstreamer returns
# n-video = 0 if we call it immediately
GObject.timeout_add(1000, callback)
def __player_error_cb(self, widget, message, detail):
self.player.stop()
self.control.set_disabled()
logging.error('ERROR MESSAGE: %s', message)
logging.error('ERROR DETAIL: %s', detail)
file_path = self.playlist_widget._items[
self.playlist_widget.get_current_playing()]['path']
mimetype = mime.get_for_file(file_path)
title = _('Error')
msg = _('This "%s" file can\'t be played') % mimetype
self._switch_canvas(False)
self._show_error_alert(title, msg)
def can_close(self):
# We need to put the Gst.State in NULL so gstreamer can
# cleanup the pipeline
self.player.stop()
return True
def read_file(self, file_path):
"""Load a file from the datastore on activity start."""
logging.debug('JukeboxActivity.read_file: %s', file_path)
title = self.metadata['title']
self.playlist_widget.load_file(file_path, title)
def write_file(self, file_path):
def write_playlist_to_file(file_path):
"""Open the file at file_path and write the playlist.
It is saved in audio/x-mpegurl format.
"""
list_file = open(file_path, 'w')
for uri in self.playlist_widget._items:
list_file.write('#EXTINF:%s\n' % uri['title'])
list_file.write('%s\n' % uri['path'])
list_file.close()
if not self.metadata['mime_type']:
self.metadata['mime_type'] = 'audio/x-mpegurl'
if self.metadata['mime_type'] == 'audio/x-mpegurl':
write_playlist_to_file(file_path)
else:
if self._playlist_jobject is None:
self._playlist_jobject = \
self.playlist_widget.create_playlist_jobject()
# Add the playlist to the playlist jobject description.
# This is only done if the activity was not started from a
# playlist or from scratch:
description = ''
for uri in self.playlist_widget._items:
description += '%s\n' % uri['title']
self._playlist_jobject.metadata['description'] = description
write_playlist_to_file(self._playlist_jobject.file_path)
datastore.write(self._playlist_jobject)
def unfullscreen(self):
activity.Activity.unfullscreen(self)
if self._on_unfullscreen_show_playlist:
self._view_toolbar._show_playlist.props.active = True
def __go_fullscreen_cb(self, toolbar):
if self._view_toolbar._show_playlist.props.active:
self._view_toolbar._show_playlist.props.active = False
self._on_unfullscreen_show_playlist = True
self.fullscreen()
def __toggle_playlist_cb(self, toolbar):
if self._view_toolbar._show_playlist.props.active:
self._playlist_box.show_all()
else:
self._playlist_box.hide()
self._video_canvas.queue_draw()
