# Copyright (C) 2008-2010 Adam Olsen
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
#
# The developers of the Exaile media player hereby grant permission
# for non-GPL compatible GStreamer and Exaile plugins to be used and
# distributed together with GStreamer and Exaile. This permission is
# above and beyond the permissions granted by the GPL license by which
# Exaile is covered. If you modify this code, you may extend this
# exception to your version of the code, but you are not obligated to
# do so. If you do not wish to do so, delete this exception statement
# from your version.
from gi.repository import Atk
from gi.repository import Gdk
from gi.repository import GLib
from gi.repository import GObject
from gi.repository import Gtk
from gi.repository import Pango
from xl import event, formatter, player, providers, settings
from xl.common import clamp
from xl.nls import gettext as _
from xlgui.widgets import menu
from xlgui.guiutil import GtkTemplate
import logging
logger = logging.getLogger(__name__)
class ProgressBarFormatter(formatter.ProgressTextFormatter):
"""
A formatter for progress bars
"""
def __init__(self, player):
formatter.ProgressTextFormatter.__init__(self, '', player)
self.on_option_set('gui_option_set', settings, 'gui/progress_bar_text_format')
event.add_ui_callback(self.on_option_set, 'gui_option_set')
def on_option_set(self, event, settings, option):
"""
Updates the internal format on setting change
"""
if option == 'gui/progress_bar_text_format':
self.props.format = settings.get_option(
'gui/progress_bar_text_format', '$current_time / $remaining_time'
)
class PlaybackProgressBar(Gtk.ProgressBar):
"""
Progress bar which automatically follows playback
"""
def __init__(self, player):
Gtk.ProgressBar.__init__(self)
self.__player = player
try:
awidget = self.get_accessible()
awidget.set_role(Atk.Role.AUDIO)
except Exception:
logger.debug("Exception setting ATK role", exc_info=True)
self.set_show_text(True)
self.reset()
self.formatter = ProgressBarFormatter(player)
self.__timer_id = None
self.__events = (
'playback_track_start',
'playback_player_end',
'playback_toggle_pause',
'playback_error',
)
for e in self.__events:
event.add_ui_callback(getattr(self, 'on_%s' % e), e, self.__player)
def destroy(self):
"""
Cleanups
"""
for e in self.__events:
event.remove_callback(getattr(self, 'on_%s' % e), e, self.__player)
def reset(self):
"""
Resets the progress bar appearance
"""
self.set_fraction(0)
self.set_text(_('Not Playing'))
def __enable_timer(self):
"""
Enables the update timer
"""
if self.__timer_id is not None:
return
interval = settings.get_option('gui/progress_update_millisecs', 1000)
if interval % 1000 == 0:
self.__timer_id = GLib.timeout_add_seconds(interval // 1000, self.on_timer)
else:
self.__timer_id = GLib.timeout_add(interval, self.on_timer)
self.on_timer()
def __disable_timer(self):
"""
Disables the update timer
"""
if self.__timer_id is not None:
GLib.source_remove(self.__timer_id)
self.__timer_id = None
def on_timer(self):
"""
Updates progress bar appearance
"""
if self.__player.current is None:
self.__disable_timer()
self.reset()
return False
self.set_fraction(self.__player.get_progress())
self.set_text(self.formatter.format())
return True
def on_playback_track_start(self, event_type, player, track):
"""
Starts update timer
"""
self.reset()
self.__enable_timer()
def on_playback_player_end(self, event_type, player, track):
"""
Stops update timer
"""
self.__disable_timer()
self.reset()
def on_playback_toggle_pause(self, event_type, player, track):
"""
Starts or stops update timer
"""
if player.is_playing():
self.__enable_timer()
elif player.is_paused():
self.__disable_timer()
def on_playback_error(self, event_type, player, message):
"""
Stops update timer
"""
self.__disable_timer()
self.reset()
class Anchor(int):
__gtype__ = GObject.TYPE_INT
for i, a in enumerate(
'CENTER NORTH NORTH_WEST NORTH_EAST SOUTH SOUTH_WEST SOUTH_EAST WEST EAST'.split()
):
setattr(Anchor, a, Anchor(i))
class Marker(GObject.Object):
"""
A marker pointing to a playback position
"""
__gproperties__ = {
'anchor': (
Anchor,
'anchor position',
'The position the marker will be anchored',
Anchor.CENTER,
Anchor.EAST,
Anchor.SOUTH,
GObject.ParamFlags.READWRITE,
),
'color': (
Gdk.RGBA,
'marker color',
'Override color of the marker',
GObject.ParamFlags.READWRITE,
),
'label': (
GObject.TYPE_STRING,
'marker label',
'Textual description of the marker',
None,
GObject.ParamFlags.READWRITE,
),
'position': (
GObject.TYPE_FLOAT,
'marker position',
'Relative position of the marker',
0,
1,
0,
GObject.ParamFlags.READWRITE,
),
'state': (
Gtk.StateType,
'marker state',
'The state of the marker',
Gtk.StateType.NORMAL,
GObject.ParamFlags.READWRITE,
),
}
__gsignals__ = {'reached': (GObject.SignalFlags.RUN_LAST, None, ())}
def __init__(self, position: float = 0):
GObject.Object.__init__(self)
self.__values = {
'anchor': Anchor.SOUTH,
'color': None,
'label': None,
'position': 0,
'state': Gtk.StateType.NORMAL,
}
self.props.position = position
def __str__(self):
"""
Informal representation
"""
if self.props.label is not None:
text = '%s (%g)' % (self.props.label, self.props.position)
else:
text = '%g' % self.props.position
return text
def __lt__(self, other):
"""
Compares positions
"""
return self.props.position < other.props.position
def __gt__(self, other):
"""
Compares positions
"""
return self.props.position > other.props.position
def do_get_property(self, gproperty):
"""
Gets a GObject property
"""
try:
return self.__values[gproperty.name]
except KeyError:
raise AttributeError('unknown property %s' % gproperty.name)
def do_set_property(self, gproperty, value):
"""
Sets a GObject property
"""
if gproperty.name not in self.__values:
raise AttributeError('unknown property %s' % gproperty.name)
self.__values[gproperty.name] = value
class MarkerManager(providers.ProviderHandler):
"""
Enables management of playback markers; namely simple
adding, removing and finding. It also takes care of
emitting signals when a marker is reached during playback.
TODO: This presumes there is only one player object present
in exaile, and that markers can only be associated with
the single player object. This class should probably be
changed to be associated with a particular player (which
requires some changes to the marker class)
"""
def __init__(self):
providers.ProviderHandler.__init__(self, 'playback-markers')
self.__events = ('playback_track_start', 'playback_track_end')
self.__timeout_id = None
for e in self.__events:
event.add_ui_callback(getattr(self, 'on_%s' % e), e)
def destroy(self):
"""
Cleanups
"""
for e in self.__events:
event.remove_callback(getattr(self, 'on_%s' % e), e)
def add_marker(self, position: float) -> Marker:
"""
Creates a new marker for a playback position
:param position: the playback position [0..1]
:returns: the new marker
"""
marker = Marker(position)
# Provider compatibility
marker.name = 'marker'
providers.register('playback-markers', marker)
return marker
def remove_marker(self, marker: Marker) -> None:
"""
Removes a playback marker
:param marker: the marker
"""
providers.unregister('playback-markers', marker)
def get_markers_at(self, position):
"""
Gets all markers located at a position
:param position: the mark position
:type position: float
:returns: (m1, m2, ...)
:rtype: (:class:`Marker`, ...)
* *m1*: the first marker
* *m2*: the second marker
* ...
"""
# Reproduce value modifications
position = Marker(position).props.position
markers = ()
for marker in providers.get('playback-markers'):
if marker.props.position == position:
markers += (marker,)
return markers
def on_playback_track_start(self, event, player, track):
"""
Starts marker watching
"""
if self.__timeout_id is not None:
GLib.source_remove(self.__timeout_id)
self.__timeout_id = GLib.timeout_add_seconds(1, self.on_timeout, player)
def on_playback_track_end(self, event, player, track):
"""
Stops marker watching
"""
if self.__timeout_id is not None:
GLib.source_remove(self.__timeout_id)
self.__timeout_id = None
def on_timeout(self, player):
"""
Triggers "reached" signal of markers
"""
if player.current is None:
self.__timeout_id = None
return
track_length = player.current.get_tag_raw('__length')
if track_length is None:
return True
playback_time = int(player.get_time())
reached_markers = (
m
for m in providers.get('playback-markers')
if int(m.props.position * track_length) == playback_time
)
for marker in reached_markers:
marker.emit('reached')
return True
__MARKERMANAGER = MarkerManager()
add_marker = __MARKERMANAGER.add_marker
remove_marker = __MARKERMANAGER.remove_marker
get_markers_at = __MARKERMANAGER.get_markers_at
class _SeekInternalProgressBar(PlaybackProgressBar):
def __init__(self, player, points, marker_scale):
PlaybackProgressBar.__init__(self, player)
self._points = points
self._seeking = False
self._marker_scale = marker_scale
def do_draw(self, context):
"""
Draws markers on top of the progress bar
"""
Gtk.ProgressBar.do_draw(self, context)
if not self._points:
return
context.set_line_width(self._marker_scale / 0.9)
style = self.get_style_context()
POW_256_2 = 256**2
for marker, points in self._points.items():
for i, (x, y) in enumerate(points):
if i == 0:
context.move_to(x, y)
else:
context.line_to(x, y)
context.close_path()
if marker.props.state in (Gtk.StateType.PRELIGHT, Gtk.StateType.ACTIVE):
c = style.get_color(Gtk.StateFlags.NORMAL)
context.set_source_rgba(c.red, c.green, c.blue, c.alpha)
else:
if marker.props.color is not None:
base = marker.props.color
else:
base = style.get_color(marker.props.state)
context.set_source_rgba(
base.red / POW_256_2,
base.green / POW_256_2,
base.blue / POW_256_2,
0.7,
)
context.fill_preserve()
if marker.props.state in (Gtk.StateType.PRELIGHT, Gtk.StateType.ACTIVE):
c = style.get_color(Gtk.StateFlags.NORMAL)
context.set_source_rgba(c.red, c.green, c.blue, c.alpha)
else:
foreground = style.get_color(marker.props.state)
context.set_source_rgba(
foreground.red / POW_256_2,
foreground.green / POW_256_2,
foreground.blue / POW_256_2,
0.7,
)
context.stroke()
def on_timer(self):
"""
Prevents update while seeking
"""
if self._seeking:
return True
return PlaybackProgressBar.on_timer(self)
class SeekProgressBar(Gtk.EventBox, providers.ProviderHandler):
"""
Playback progress bar which allows for seeking
and setting positional markers
"""
CSS = Gtk.CssProvider()
CSS.load_from_data(
b'''
/* Make the text easier to read on Adwaita */
progressbar {
color: unset;
font-size: unset;
}
'''
)
__gproperties__ = {
'marker-scale': (
GObject.TYPE_FLOAT,
'marker scale',
'Scaling of markers',
0,
1,
0.7,
GObject.ParamFlags.READWRITE,
)
}
__gsignals__ = {
'button-press-event': 'override',
'button-release-event': 'override',
'motion-notify-event': 'override',
'notify': 'override',
'key-press-event': 'override',
'key-release-event': 'override',
'scroll-event': 'override',
'marker-reached': (
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_BOOLEAN,
(Marker,),
GObject.signal_accumulator_true_handled,
),
}
def __init__(self, player, use_markers=True):
"""
TODO: markers aren't designed for more than one player, once
they are we can get rid of the use_markers option
"""
Gtk.EventBox.__init__(self)
points = {}
self.__player = player
self.__values = {'marker-scale': 0.7}
self._points = points
self.__progressbar = _SeekInternalProgressBar(
player, points, self.__values['marker-scale']
)
self._progressbar_menu = None
if use_markers:
self._progressbar_menu = ProgressBarContextMenu(self)
self._marker_menu = MarkerContextMenu(self)
self._marker_menu.connect('deactivate', self.on_marker_menu_deactivate)
providers.ProviderHandler.__init__(self, 'playback-markers')
sc = self.__progressbar.get_style_context()
sc.add_provider(self.CSS, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
self.add_events(
Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK
| Gdk.EventMask.POINTER_MOTION_MASK
| Gdk.EventMask.LEAVE_NOTIFY_MASK
| Gdk.EventMask.SCROLL_MASK
)
self.set_can_focus(True)
self.connect('hierarchy-changed', self.on_hierarchy_changed)
self.connect('scroll-event', self.on_scroll_event)
self.add(self.__progressbar)
self.show_all()
def get_label(self, marker):
"""
Builds the most appropriate label
markup to describe a marker
:param marker: the marker
:type marker: :class:`Marker`
:returns: the label
:rtype: string
"""
markup = None
if self.__player.current:
length = self.__player.current.get_tag_raw('__length')
if length is not None:
length = length * marker.props.position
length = formatter.LengthTagFormatter.format_value(length)
if marker.props.label:
markup = '%s (%s)' % (marker.props.label, length)
else:
markup = '%s' % length
else:
if marker.props.label:
markup = '%s (%d%%)' % (
marker.props.label,
int(marker.props.position * 100),
)
else:
markup = '%d%%' % int(marker.props.position * 100)
return markup
def _is_marker_hit(self, marker, check_x, check_y):
"""
Checks whether a marker is hit by a point
:param marker: the marker
:type marker: :class:`Marker`
:param check_x: the x location to check
:type check_x: float
:param check_y: the y location to check
:type check_y: float
:returns: whether the marker was hit
:rtype: bool
"""
points = self._points[marker]
x, y, width, height = self._get_bounding_box(points)
if x <= check_x <= width and y <= check_y <= height:
return True
return False
def _get_points(self, marker, width=None, height=None):
"""
Calculates the points necessary
to represent a marker
:param marker: the marker
:type marker: :class:`Marker`
:param width: area width override
:type width: int
:param height: area height override
:type height: int
:returns: ((x1, y1), (x2, y2), ...)
:rtype: ((float, float), ...)
* *x1*: the x coordinate of the first point
* *y1*: the y coordinate of the first point
* *x2*: the x coordinate of the second point
* *y2*: the y coordinate of the second point
* ...
"""
points = ()
alloc = self.get_allocation()
width = width or alloc.width
height = height or alloc.height
position = width * marker.props.position
marker_scale = int(height * self.props.marker_scale)
# Adjustment by half of the line width
offset = self.props.marker_scale / 0.9 / 2
if marker.props.anchor == Anchor.NORTH_WEST:
points = (
(position - offset, offset),
(position + marker_scale * 0.75 - offset, offset),
(position - offset, marker_scale * 0.75 + offset),
)
elif marker.props.anchor == Anchor.NORTH:
points = (
(position - offset, marker_scale // 2 + offset),
(position + marker_scale // 2 - offset, offset),
(position - marker_scale // 2 - offset, offset),
)
elif marker.props.anchor == Anchor.NORTH_EAST:
points = (
(position - marker_scale * 0.75 - offset, offset),
(position - offset, offset),
(position - offset, marker_scale * 0.75 + offset),
)
elif marker.props.anchor == Anchor.EAST:
points = (
(position - marker_scale // 2 - offset, height // 2 + offset),
(position - offset, height // 2 - marker_scale // 2 + offset),
(position - offset, height // 2 + marker_scale // 2 + offset),
)
elif marker.props.anchor == Anchor.SOUTH_EAST:
points = (
(position - offset, height - offset),
(position - offset, height - marker_scale * 0.75 - offset),
(position - marker_scale * 0.75 - offset, height - offset),
)
elif marker.props.anchor == Anchor.SOUTH:
points = (
(position - offset, height - marker_scale // 2 - offset),
(position + marker_scale // 2 - offset, height - offset),
(position - marker_scale // 2 - offset, height - offset),
)
elif marker.props.anchor == Anchor.SOUTH_WEST:
points = (
(position - offset, height - offset),
(position + marker_scale * 0.75 - offset, height - offset),
(position - offset, height - marker_scale * 0.75 - offset),
)
elif marker.props.anchor == Anchor.WEST:
points = (
(position + marker_scale // 2 - offset, height // 2 + offset),
(position - offset, height // 2 - marker_scale // 2 + offset),
(position - offset, height // 2 + marker_scale // 2 + offset),
)
elif marker.props.anchor == Anchor.CENTER:
points = (
(position - offset, height // 2 - marker_scale // 2 + offset),
(position + marker_scale // 2 - offset, height // 2 + offset),
(position - offset, height // 2 + marker_scale // 2 + offset),
(position - marker_scale // 2 - offset, height // 2 + offset),
)
return points
def _get_bounding_box(self, points):
"""
Calculates the axis aligned bounding box
of a sequence of points
:param points: ((x1, y1), (x2, y2), ...)
:type points: ((float, float), ...)
:returns: (x, y, width, height)
:rtype: (float, float, float, float)
* *x*: the x coordinate of the box
* *y*: the y coordinate of the box
* *width*: the width of the box
* *height*: the height of the box
"""
xs, ys = zip(*points)
return min(xs), min(ys), max(xs), max(ys)
def seek(self, position):
"""
Seeks within the current track
"""
if self.__player.current:
self.__player.set_progress(position)
self.update_progress()
def update_progress(self):
"""
Updates the progress bar and the time with data from the player
"""
if self.__player.current:
length = self.__player.current.get_tag_raw('__length')
if length is not None:
position = float(self.__player.get_time()) / length
self.__progressbar.set_fraction(position)
self.__progressbar.set_text(
self.__progressbar.formatter.format(current_time=length * position)
)
def do_get_property(self, gproperty):
"""
Gets a GObject property
"""
try:
return self.__values[gproperty.name]
except KeyError:
raise AttributeError('unknown property %s' % property.name)
def do_set_property(self, gproperty, value):
"""
Sets a GObject property
"""
try:
self.__values[gproperty.name] = value
except KeyError:
raise AttributeError('unknown property %s' % property.name)
def do_notify(self, gproperty):
"""
Reacts to GObject property changes
"""
if gproperty.name == 'marker-scale':
for marker in self._points:
self._points[marker] = self._get_points(marker)
self.__progressbar._marker_scale = self.__values['marker-scale']
self.__progressbar.queue_draw()
def do_size_allocate(self, allocation):
"""
Recalculates the marker points
"""
oldallocation = self.get_allocation()
Gtk.EventBox.do_size_allocate(self, allocation)
if allocation != oldallocation:
for marker in self._points:
self._points[marker] = self._get_points(marker)
def do_button_press_event(self, event):
"""
Prepares seeking
"""
event = event.button
hit_markers = []
for marker in self._points:
if self._is_marker_hit(marker, event.x, event.y):
if marker.props.state in (Gtk.StateType.NORMAL, Gtk.StateType.PRELIGHT):
marker.props.state = Gtk.StateType.ACTIVE
hit_markers += [marker]
hit_markers.sort()
if event.button == Gdk.BUTTON_PRIMARY:
if self.__player.current is None:
return True
length = self.__player.current.get_tag_raw('__length')
if length is None:
return True
if len(hit_markers) > 0:
self.seek(hit_markers[0].props.position)
else:
fraction = event.x / self.get_allocation().width
fraction = clamp(fraction, 0, 1)
self.__progressbar.set_fraction(fraction)
self.__progressbar.set_text(
_('Seeking: %s')
% self.__progressbar.formatter.format(
current_time=length * fraction
)
)
self.__progressbar._seeking = True
elif event.triggers_context_menu():
if len(hit_markers) > 0:
self._marker_menu.popup(event, tuple(hit_markers))
elif self._progressbar_menu is not None:
self._progressbar_menu.popup(event)
def do_button_release_event(self, event):
"""
Completes seeking
"""
event = event.button
for marker in self._points:
if marker.props.state == Gtk.StateType.ACTIVE:
marker.props.state = Gtk.StateType.PRELIGHT
if event.button == Gdk.BUTTON_PRIMARY and self.__progressbar._seeking:
fraction = event.x / self.get_allocation().width
fraction = clamp(fraction, 0, 1)
self.seek(fraction)
self.__progressbar._seeking = False
def do_motion_notify_event(self, event):
"""
Updates progress bar while seeking
and updates marker states on hover
"""
self.set_tooltip_markup(None)
if self.__progressbar._seeking:
press_event = Gdk.EventButton.new(Gdk.EventType.BUTTON_PRESS)
press_event.button = Gdk.BUTTON_PRIMARY
press_event.x = event.x
press_event.y = event.y
self.emit('button-press-event', press_event)
else:
hit_markers = []
for marker in self._points:
if self._is_marker_hit(marker, event.x, event.y):
if marker.props.state == Gtk.StateType.NORMAL:
marker.props.state = Gtk.StateType.PRELIGHT
hit_markers += [marker]
else:
if marker.props.state == Gtk.StateType.PRELIGHT:
marker.props.state = Gtk.StateType.NORMAL
if len(hit_markers) > 0:
hit_markers.sort()
markup = ', '.join([self.get_label(m) for m in hit_markers])
self.set_tooltip_markup(markup)
self.trigger_tooltip_query()
def do_leave_notify_event(self, event):
"""
Resets marker states
"""
for marker in self._points:
# Leave other states intact
if marker.props.state == Gtk.StateType.PRELIGHT:
marker.props.state = Gtk.StateType.NORMAL
def do_key_press_event(self, event):
"""
Prepares seeking via keyboard interaction
* Alt+Up/Right: seek 1% forward
* Alt+Down/Left: seek 1% backward
"""
_, state = event.get_state()
if state & Gtk.StateType.INSENSITIVE:
return
if not state & Gdk.ModifierType.MOD1_MASK:
return
if event.keyval in (Gdk.KEY_Up, Gdk.KEY_Right):
direction = 1
elif event.keyval in (Gdk.KEY_Down, Gdk.KEY_Left):
direction = -1
else:
return
press_event = Gdk.Event.new(Gdk.EventType.BUTTON_PRESS)
press_event.button = Gdk.BUTTON_PRIMARY
new_fraction = self.__progressbar.get_fraction() + 0.01 * direction
alloc = self.get_allocation()
press_event.x = alloc.width * new_fraction
press_event.y = float(alloc.y)
self.emit('button-press-event', press_event)
def do_key_release_event(self, event):
"""
Completes seeking via keyboard interaction
"""
_, state = event.get_state()
if not state & Gdk.ModifierType.MOD1_MASK:
return
if event.keyval in (Gdk.KEY_Up, Gdk.KEY_Right):
direction = 1
elif event.keyval in (Gdk.KEY_Down, Gdk.KEY_Left):
direction = -1
else:
return
release_event = Gdk.Event.new(Gdk.EventType.BUTTON_RELEASE)
release_event.button = Gdk.BUTTON_PRIMARY
new_fraction = self.__progressbar.get_fraction() + 0.01 * direction
alloc = self.get_allocation()
release_event.x = alloc.width * new_fraction
release_event.y = float(alloc.y)
self.emit('button-release-event', release_event)
def on_scroll_event(self, widget, event):
"""
Seek on scroll as VLC does
"""
if not self.__player.current:
return True
if self.__player.current.get_tag_raw('__length') is None:
return True
progress = self.__player.get_progress()
progress_delta = 0.05 # 5% of track length
progress_delta_small = 0.005 # 0.5% of track length
if (
event.direction == Gdk.ScrollDirection.DOWN
or event.direction == Gdk.ScrollDirection.LEFT
):
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
new_progress = progress - progress_delta_small
else:
new_progress = progress - progress_delta
elif (
event.direction == Gdk.ScrollDirection.UP
or event.direction == Gdk.ScrollDirection.RIGHT
):
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
new_progress = progress + progress_delta_small
else:
new_progress = progress + progress_delta
elif event.direction == Gdk.ScrollDirection.SMOOTH:
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
new_progress = progress + progress_delta_small * (
event.deltax + event.deltay
)
else:
new_progress = progress + progress_delta * (event.deltax + event.deltay)
self.__player.set_progress(clamp(new_progress, 0, 1))
self.update_progress()
return True
def on_hierarchy_changed(self, widget, old_toplevel):
"""
Sets up editing cancel on toplevel focus out
"""
# Disconnect from previous toplevel.
prev_conn = getattr(self, '_SeekProgressBar__prev_focus_out_conn', None)
if prev_conn:
prev_conn[0].disconnect(prev_conn[1])
del self.__prev_focus_out_conn
# Connect to new toplevel and store the connection, but only if it's an
# actual toplevel window.
toplevel = self.get_toplevel()
if toplevel.is_toplevel():
conn = toplevel.connect(
'focus-out-event', lambda w, e: self.emit('focus-out-event', e.copy())
)
self.__prev_focus_out_conn = (toplevel, conn)
def on_marker_menu_deactivate(self, menu):
"""
Makes sure to reset states of
previously selected markers
"""
for marker in self._points:
marker.props.state = Gtk.StateType.NORMAL
self.__progressbar.queue_draw()
def on_marker_notify(self, marker, gproperty):
"""
Recalculates marker points on position changes
"""
if gproperty.name in ('anchor', 'position'):
self._points[marker] = self._get_points(marker)
self.__progressbar.queue_draw()
def on_provider_added(self, marker):
"""
Calculates points after marker addition
:param marker: the new marker
:type marker: :class:`Marker`
"""
notify_id = marker.connect('notify', self.on_marker_notify)
setattr(marker, '%s_notify_id' % id(self), notify_id)
self._points[marker] = self._get_points(marker)
self.__progressbar.queue_draw()
def on_provider_removed(self, marker):
"""
Removes points from internal cache
:param marker: the marker
:type marker: :class:`Marker`
"""
notify_id = getattr(marker, '%s_notify_id' % id(self))
if notify_id is not None:
marker.disconnect(notify_id)
del self._points[marker]
self.__progressbar.queue_draw()
# HACK: These methods implement the PlaybackAdapter interface (passing the
# calls to the internal progress bar, which is an actual PlaybackAdapter).
# This class only pretends to be a PlaybackAdapter because we don't want
# the mixin behavior here.
def on_playback_track_start(self, event, player, track):
self.__progressbar.on_playback_track_start(event, player, track)
def on_playback_track_end(self, event, player, track):
self.__progressbar.on_playback_track_end(event, player, track)
def on_playback_player_end(self, event, player, track):
self.__progressbar.on_playback_player_end(event, player, track)
def on_playback_toggle_pause(self, event, player, track):
self.__progressbar.on_playback_toggle_pause(event, player, track)
def on_playback_error(self, event, player, message):
self.__progressbar.on_playback_error(event, player, message)
class ProgressBarContextMenu(menu.ProviderMenu):
"""
Progress bar specific context menu
"""
def __init__(self, progressbar):
"""
:param progressbar: the progress bar
:type progressbar: :class:`PlaybackProgressBar`
"""
menu.ProviderMenu.__init__(self, 'progressbar-context-menu', progressbar)
self._position = -1
def get_context(self):
"""
Retrieves the context
"""
context = {'current-position': self._position}
return context
def popup(self, event):
"""
Pops up the menu
:param event: an event
:type event: :class:`Gdk.Event`
"""
self._position = event.x / self._parent.get_allocation().width
menu.ProviderMenu.popup(self, event)
class MarkerContextMenu(menu.ProviderMenu):
"""
Marker specific context menu
"""
def __init__(self, markerbar):
"""
:param markerbar: the marker capable progress bar
:type markerbar: :class:`SeekProgressBar`
"""
menu.ProviderMenu.__init__(self, 'playback-marker-context-menu', markerbar)
self._markers = ()
self._position = -1
def regenerate_menu(self):
"""
Builds the menu, with submenu if appropriate
"""
for marker in self._markers:
label = self._parent.get_label(marker)
if label is None:
continue
markup_data = Pango.parse_markup(label, -1, '0')
label_item = Gtk.MenuItem.new_with_mnemonic(markup_data[2])
self.append(label_item)
if len(self._markers) > 1:
item_menu = Gtk.Menu()
label_item.set_submenu(item_menu)
else:
item_menu = self
label_item.set_sensitive(False)
self.append(Gtk.SeparatorMenuItem())
context = {
'current-marker': marker,
'selected-markers': self._markers,
'current-position': self._position,
}
for item in self._items:
i = item.factory(self, self._parent, context)
item_menu.append(i)
self.show_all()
def popup(self, event, markers):
"""
Pops up the menu
:param event: an event
:type event: :class:`Gdk.Event`
:param markers: (m1, m2, ...)
:type markers: (:class:`Marker`, ...)
"""
self._markers = markers
self._position = event.x / self._parent.get_allocation().width
menu.ProviderMenu.popup(self, event)
class MoveMarkerMenuItem(menu.MenuItem):
"""
Menu item allowing for movement of markers
"""
def __init__(self, name, after, display_name=_('Move'), icon_name=None):
menu.MenuItem.__init__(self, name, None, after)
self._parent = None
self._display_name = display_name
self._icon_name = icon_name
self._marker = None
self._reset_position = -1
def factory(self, menu, parent, context):
"""
Generates the menu item
"""
self._parent = parent
item = Gtk.ImageMenuItem.new_with_mnemonic(self._display_name)
if self._icon_name is not None:
item.set_image(
Gtk.Image.new_from_icon_name(self._icon_name, Gtk.IconSize.MENU)
)
item.connect('activate', self.on_activate, parent, context)
parent.connect('button-press-event', self.on_parent_button_press_event)
parent.connect('motion-notify-event', self.on_parent_motion_notify_event)
parent.connect('focus-out-event', self.on_parent_focus_out_event)
return item
def move_begin(self, marker):
"""
Captures the current marker for movement
:param marker: the marker
:type marker: :class:`Marker`
:returns: whether a marker could be captured
:rtype: bool
"""
self.move_cancel()
if marker is not None:
self._marker = marker
self._marker.props.state = Gtk.StateType.ACTIVE
self._reset_position = marker.props.position
self._parent.props.window.set_cursor(
Gdk.Cursor.new(Gdk.CursorType.SB_H_DOUBLE_ARROW)
)
return True
return False
def move_update(self, position):
"""
Moves the marker
:param position: the current marker position
:type position: float
:returns: whether a marker could be moved
:rtype: bool
"""
if self._marker is not None:
self._marker.props.position = position
label = self._parent.get_label(self._marker)
self._parent.set_tooltip_markup(label)
return True
return False
def move_finish(self):
"""
Finishes movement and releases the marker
:returns: whether the movement could be finished
:rtype: bool
"""
if self._marker is not None:
self._marker.props.state = Gtk.StateType.NORMAL
self._marker = None
self._reset_position = -1
self._parent.props.window.set_cursor(None)
return True
return False
def move_cancel(self):
"""
Cancels movement and releases the marker
:returns: whether the movement could be cancelled
:rtype: bool
"""
if self._marker is not None:
self._marker.props.position = self._reset_position
self._marker.props.state = Gtk.StateType.NORMAL
self._marker = None
self._reset_position = -1
self._parent.props.window.set_cursor(None)
return True
return False
def on_activate(self, widget, parent, context):
"""
Starts movement of markers
"""
self.move_begin(context.get('current-marker', None))
def on_parent_button_press_event(self, widget, event):
"""
Finishes or cancels movement of markers
"""
if event.button == Gdk.BUTTON_PRIMARY:
return self.move_finish()
elif event.triggers_context_menu():
return self.move_cancel()
return False
def on_parent_motion_notify_event(self, widget, event):
"""
Moves markers
"""
position = event.x / widget.get_allocation().width
return self.move_update(position)
def on_parent_focus_out_event(self, widget, event):
"""
Cancels movement of markers
"""
self.move_cancel()
class NewMarkerMenuItem(MoveMarkerMenuItem):
"""
Menu item allowing for insertion
and instant movement of a marker
"""
def __init__(self, name, after):
MoveMarkerMenuItem.__init__(self, name, after, _('New Marker'), 'list-add')
def move_cancel(self):
"""
Cancels movement and insertion of the marker
:param parent: the parent
:type parent: :class:`SeekProgressBar`
:returns: whether the movement could be cancelled
:rtype: bool
"""
if self._marker is not None:
remove_marker(self._marker)
self._marker = None
self._reset_position = -1
self._parent.props.window.set_cursor(None)
return True
return False
def on_activate(self, widget, parent, context):
"""
Inserts a new marker and starts movement
"""
context['current-marker'] = add_marker(context['current-position'])
MoveMarkerMenuItem.on_activate(self, widget, parent, context)
# XXX: Example implementation only
# Bookmarks: "Add bookmark" (1 new marker)
# A-B-Repeat: "Repeat" (2 new marker, NW, NE)
def __create_progressbar_context_menu():
items = []
items.append(NewMarkerMenuItem('new-marker', []))
for item in items:
providers.register('progressbar-context-menu', item)
__create_progressbar_context_menu()
def __create_marker_context_menu():
items = []
def on_jumpto_item_activate(widget, name, parent, context):
# parent.seek(context['current-marker'].props.position)
position = context['current-marker'].props.position
player.PLAYER.set_progress(position)
def on_remove_item_activate(widget, name, parent, context):
providers.unregister('playback-markers', context['current-marker'])
items.append(
menu.simple_menu_item(
'jumpto-marker', [], _("_Jump to"), 'go-jump', on_jumpto_item_activate
)
)
items.append(MoveMarkerMenuItem('move-marker', [items[-1].name]))
items.append(
menu.simple_menu_item(
'remove-marker',
[items[-1].name],
_("_Remove Marker"),
'list-remove',
on_remove_item_activate,
)
)
for item in items:
providers.register('playback-marker-context-menu', item)
__create_marker_context_menu()
@GtkTemplate('ui', 'widgets', 'volume_control.ui')
class VolumeControl(Gtk.Box):
"""
Encapsulates a button and a slider to
control the volume indicating the current
status via icon and tooltip
"""
__gtype_name__ = 'VolumeControl'
(button, slider, button_image, slider_adjustment) = GtkTemplate.Child.widgets(4)
def __init__(self, player):
Gtk.Box.__init__(self)
self.init_template()
self.button.add_events(Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.SCROLL_MASK)
self.__volume_setting = '%s/volume' % player._name
self.restore_volume = settings.get_option(self.__volume_setting, 1)
self.icon_names = ['low', 'medium', 'high']
self.__update(self.restore_volume)
event.add_ui_callback(self.on_option_set, '%s_option_set' % player._name)
def __update(self, volume):
"""
Sets the volume level indicator
"""
icon_name = 'audio-volume-muted'
tooltip = _('Muted')
if volume > 0:
i = clamp(int(round(volume * 2)), 0, len(self.icon_names) - 1)
icon_name = 'audio-volume-%s' % self.icon_names[i]
# TRANSLATORS: Volume percentage
tooltip = _('%d%%') % (volume * 100)
else:
volume = 0
if volume == 1.0:
tooltip = _('Full Volume')
if volume > 0:
self.button.set_active(False)
self.button_image.set_from_icon_name(icon_name, Gtk.IconSize.BUTTON)
self.button.set_tooltip_text(tooltip)
self.slider.set_value(volume)
self.slider.set_tooltip_text(tooltip)
@GtkTemplate.Callback
def on_scroll_event(self, widget, event):
"""
Changes the volume on scrolling
"""
page_increment = self.slider_adjustment.props.page_increment
step_increment = self.slider_adjustment.props.step_increment
value = self.slider.get_value()
if event.direction in (Gdk.ScrollDirection.DOWN, Gdk.ScrollDirection.LEFT):
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
self.slider.set_value(value - page_increment)
else:
self.slider.set_value(value - step_increment)
return True
elif event.direction in (Gdk.ScrollDirection.UP, Gdk.ScrollDirection.RIGHT):
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
self.slider.set_value(value + page_increment)
else:
self.slider.set_value(value + step_increment)
return True
elif event.direction == Gdk.ScrollDirection.SMOOTH:
delta = event.delta_x - event.delta_y
if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
self.slider.set_value(value + delta * page_increment)
else:
self.slider.set_value(value + delta * step_increment)
return True
return False
@GtkTemplate.Callback
def on_button_toggled(self, button):
"""
Mutes or unmutes the volume
"""
if button.get_active():
self.restore_volume = settings.get_option(self.__volume_setting, 1)
volume = 0
else:
volume = self.restore_volume
if self.restore_volume > 0:
settings.set_option(self.__volume_setting, volume)
@GtkTemplate.Callback
def on_slider_value_changed(self, slider):
"""
Stores the preferred volume
"""
settings.set_option(self.__volume_setting, slider.get_value())
@GtkTemplate.Callback
def on_slider_key_press_event(self, slider, event):
"""
Changes the volume on key press
while the slider is focused
"""
page_increment = slider.get_adjustment().props.page_increment
step_increment = slider.get_adjustment().props.step_increment
value = slider.get_value()
if event.keyval == Gdk.KEY_Down:
slider.set_value(value - step_increment)
return True
elif event.keyval == Gdk.KEY_Page_Down:
slider.set_value(value - page_increment)
return True
elif event.keyval == Gdk.KEY_Up:
slider.set_value(value + step_increment)
return True
elif event.keyval == Gdk.KEY_Page_Up:
slider.set_value(value + page_increment)
return True
return False
def on_option_set(self, event, sender, option):
"""
Updates the volume indication
"""
if option == self.__volume_setting:
self.__update(settings.get_option(option, 1))
def playpause(player):
if player.get_state() in ('playing', 'paused'):
player.toggle_pause()
else:
from xlgui import main
page = main.get_selected_playlist()
if page:
pl = page.playlist
if len(pl) == 0:
return
try:
idx = page.view.get_selected_paths()[0][0]
except IndexError:
idx = 0
player.queue.set_current_playlist(pl)
pl.current_position = idx
player.queue.play(track=pl.current)
def PlayPauseMenuItem(name, player, after):
def factory(name, after, player):
if player.is_playing():
icon_name = 'media-playback-pause'
label = _("_Pause")
else:
icon_name = 'media-playback-start'
label = _("P_lay")
return menu.simple_menu_item(
name, after, label, icon_name, callback=lambda *args: playpause(player)
)
return factory(name, after, player)
def NextMenuItem(name, player, after):
return menu.simple_menu_item(
name,
after,
_("_Next Track"),
'media-skip-forward',
callback=lambda *args: player.queue.next(),
)
def PrevMenuItem(name, player, after):
return menu.simple_menu_item(
name,
after,
_("_Previous Track"),
'media-skip-backward',
callback=lambda *args: player.queue.prev(),
)
def StopMenuItem(name, player, after):
return menu.simple_menu_item(
name,
after,
_("_Stop"),
'media-playback-stop',
callback=lambda *args: player.stop(),
)