e42037ce6f
deadbeef is checked to ensure it's running before doing anything, otherwise a lot of useless data is pulled in, and the if statement to check whether or not the player is stopped is now integrated into the query at startup instead of running a separate query every time.
143 lines
6.2 KiB
Python
143 lines
6.2 KiB
Python
# pylint: disable=C0111,R0903
|
|
|
|
"""Displays the current song being played in DeaDBeeF and provides
|
|
some media control bindings.
|
|
Left click toggles pause, scroll up skips the current song, scroll
|
|
down returns to the previous song.
|
|
|
|
Requires the following library:
|
|
* subprocess
|
|
Parameters:
|
|
* deadbeef.format: Format string (defaults to "{artist} - {title}")
|
|
Available values are: {artist}, {title}, {album}, {length},
|
|
{trackno}, {year}, {comment},
|
|
{copyright}, {time}
|
|
This is deprecated, but much simpler.
|
|
* deadbeef.tf_format: A foobar2000 title formatting-style format string.
|
|
These can be much more sophisticated than the standard
|
|
format strings. This is off by default, but specifying
|
|
any tf_format will enable it. If both deadbeef.format
|
|
and deadbeef.tf_format are specified, deadbeef.tf_format
|
|
takes priority.
|
|
* deadbeef.tf_format_if_stopped: Controls whether or not the tf_format format
|
|
string should be displayed even if no song is paused or
|
|
playing. This could be useful if you want to implement
|
|
your own stop strings with the built in logic. Any non-
|
|
null value will enable this (by default the module will
|
|
hide itself when the player is stopped).
|
|
* deadbeef.previous: Change binding for previous song (default is left click)
|
|
* deadbeef.next: Change binding for next song (default is right click)
|
|
* deadbeef.pause: Change binding for toggling pause (default is middle click)
|
|
Available options for deadbeef.previous, deadbeef.next and deadbeef.pause are:
|
|
LEFT_CLICK, RIGHT_CLICK, MIDDLE_CLICK, SCROLL_UP, SCROLL_DOWN
|
|
|
|
"""
|
|
import sys
|
|
|
|
import bumblebee.input
|
|
import bumblebee.output
|
|
import bumblebee.engine
|
|
|
|
from bumblebee.output import scrollable
|
|
|
|
try:
|
|
import subprocess
|
|
except ImportError:
|
|
pass
|
|
|
|
class Module(bumblebee.engine.Module):
|
|
def __init__(self, engine, config):
|
|
super(Module, self).__init__(engine, config,
|
|
bumblebee.output.Widget(full_text=self.deadbeef)
|
|
)
|
|
buttons = {"LEFT_CLICK": bumblebee.input.LEFT_MOUSE,
|
|
"RIGHT_CLICK": bumblebee.input.RIGHT_MOUSE,
|
|
"MIDDLE_CLICK": bumblebee.input.MIDDLE_MOUSE,
|
|
"SCROLL_UP": bumblebee.input.WHEEL_UP,
|
|
"SCROLL_DOWN": bumblebee.input.WHEEL_DOWN,
|
|
}
|
|
|
|
self._song = ""
|
|
self._format = self.parameter("format", "{artist} - {title}")
|
|
self._tf_format = self.parameter("tf_format", "")
|
|
self._show_tf_when_stopped = bool(self.parameter("tf_format_if_stopped", ""))
|
|
prev_button = self.parameter("previous", "LEFT_CLICK")
|
|
next_button = self.parameter("next", "RIGHT_CLICK")
|
|
pause_button = self.parameter("pause", "MIDDLE_CLICK")
|
|
|
|
self.now_playing = ["deadbeef", "--nowplaying", "%a;%t;%b;%l;%n;%y;%c;%r;%e"]
|
|
self.now_playing_tf = ["deadbeef", "--nowplaying-tf", ""]
|
|
cmd = "deadbeef "
|
|
|
|
engine.input.register_callback(self, button=buttons[prev_button],
|
|
cmd=cmd + "--prev")
|
|
engine.input.register_callback(self, button=buttons[next_button],
|
|
cmd=cmd + "--next")
|
|
engine.input.register_callback(self, button=buttons[pause_button],
|
|
cmd=cmd + "--play-pause")
|
|
|
|
# modify the tf_format if we don't want it to show on stop
|
|
# this adds conditions to the query itself, rather than
|
|
# polling to see if deadbeef is running
|
|
# doing this reduces the number of calls we have to make
|
|
if self._tf_format and not self._show_tf_when_stopped:
|
|
self._tf_format = "$if($or(%isplaying%,%ispaused%),{query})".format(query=self._tf_format)
|
|
|
|
@scrollable
|
|
def deadbeef(self, widget):
|
|
return self.string_song
|
|
|
|
def hidden(self):
|
|
return self.string_song == ""
|
|
|
|
def update(self, widgets):
|
|
try:
|
|
if self._tf_format == "": # no tf format set, use the old style
|
|
return self.update_standard(widgets)
|
|
return self.update_tf(widgets)
|
|
except Exception:
|
|
self._song = "error"
|
|
|
|
def update_tf(self, widgets):
|
|
## ensure that deadbeef is actually running
|
|
## easiest way to do this is to check --nowplaying for
|
|
## the string "nothing"
|
|
if read_process(self.now_playing) == "nothing":
|
|
self._song = ""
|
|
return
|
|
## perform the actual query -- these can be much more sophisticated
|
|
self.now_playing_tf[-1] = self._tf_format
|
|
data = read_process(self.now_playing_tf)
|
|
self._song = data
|
|
|
|
def update_standard(self, widgets):
|
|
data = read_process(self.now_playing)
|
|
if data == "nothing":
|
|
self._song = ""
|
|
else:
|
|
data = data.split(";")
|
|
self._song = self._format.format(artist=data[0],
|
|
title=data[1],
|
|
album=data[2],
|
|
length=data[3],
|
|
trackno=data[4],
|
|
year=data[5],
|
|
comment=data[6],
|
|
copyright=data[7],
|
|
time=data[8])
|
|
|
|
@property
|
|
def string_song(self):
|
|
"""\
|
|
Returns the current song as a string, either as a unicode() (Python <
|
|
3) or a regular str() (Python >= 3)
|
|
"""
|
|
if sys.version_info.major < 3:
|
|
return unicode(self._song)
|
|
return str(self._song)
|
|
|
|
def read_process(command):
|
|
proc = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
|
|
return proc.stdout.read()
|
|
|
|
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|