262 lines
7.1 KiB
Lua
262 lines
7.1 KiB
Lua
-- Volume Control
|
|
local awful = require("awful")
|
|
local wibox = require("wibox")
|
|
local gears = require("gears")
|
|
local naughty = require("naughty")
|
|
|
|
-- compatibility fallbacks for 3.5:
|
|
local timer = gears.timer or timer
|
|
local spawn = awful.spawn or awful.util.spawn
|
|
local watch = awful.spawn and awful.spawn.with_line_callback
|
|
|
|
local function exec(command, callback)
|
|
awful.spawn.easy_async(command, callback or function() end)
|
|
end
|
|
|
|
|
|
------------------------------------------
|
|
-- Private utility functions
|
|
------------------------------------------
|
|
|
|
local function substitute(template, context)
|
|
if type(template) == "string" then
|
|
return (template:gsub("%${([%w_]+)}", function(key)
|
|
return tostring(context[key] or "default")
|
|
end))
|
|
else
|
|
-- function / functor:
|
|
return template(context)
|
|
end
|
|
end
|
|
|
|
local function new(self, ...)
|
|
local instance = setmetatable({}, {__index = self})
|
|
return instance:init(...) or instance
|
|
end
|
|
|
|
local function class(base)
|
|
return setmetatable({new = new}, {
|
|
__call = new,
|
|
__index = base,
|
|
})
|
|
end
|
|
|
|
------------------------------------------
|
|
-- Volume control interface
|
|
------------------------------------------
|
|
|
|
local vcontrol = class()
|
|
|
|
function vcontrol:init(args)
|
|
self.callbacks = {}
|
|
self.cmd = "amixer"
|
|
self.device = args.device or nil
|
|
self.cardid = args.cardid or nil
|
|
self.channel = args.channel or "Master"
|
|
self.step = args.step or '5%'
|
|
|
|
self.timer = timer({ timeout = args.timeout or 0.5 })
|
|
self.timer:connect_signal("timeout", function() self:get() end)
|
|
self.timer:start()
|
|
|
|
if args.listen and watch then
|
|
self.listener = watch({'stdbuf', '-oL', 'alsactl', 'monitor'}, {
|
|
stdout = function(line) self:get() end,
|
|
})
|
|
awesome.connect_signal("exit", function()
|
|
awesome.kill(self.listener, awesome.unix_signal.SIGTERM)
|
|
end)
|
|
end
|
|
end
|
|
|
|
function vcontrol:register(callback)
|
|
if callback then
|
|
table.insert(self.callbacks, callback)
|
|
end
|
|
end
|
|
|
|
function vcontrol:action(action)
|
|
if self[action] then self[action](self)
|
|
elseif type(action) == "function" then action(self)
|
|
elseif type(action) == "string" then spawn(action)
|
|
end
|
|
end
|
|
|
|
function vcontrol:update(status)
|
|
local volume = status:match("(%d?%d?%d)%%")
|
|
local state = status:match("%[(o[nf]*)%]")
|
|
if volume and state then
|
|
local volume = tonumber(volume)
|
|
local state = state:lower()
|
|
local muted = state == "off"
|
|
for _, callback in ipairs(self.callbacks) do
|
|
callback(self, {
|
|
volume = volume,
|
|
state = state,
|
|
muted = muted,
|
|
on = not muted,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
function vcontrol:mixercommand(args, callback)
|
|
local args = awful.util.table.join(
|
|
{self.cmd},
|
|
(self.cmd == "amixer") and {"-M"} or {},
|
|
self.device and {"-D", self.device} or {},
|
|
self.cardid and {"-c", self.cardid} or {},
|
|
args)
|
|
exec(args, callback or function(output)
|
|
self:update(output)
|
|
end)
|
|
end
|
|
|
|
function vcontrol:get()
|
|
self:mixercommand({ "get", self.channel })
|
|
end
|
|
|
|
function vcontrol:up()
|
|
self:mixercommand({ "set", self.channel, self.step .. "+" })
|
|
end
|
|
|
|
function vcontrol:down()
|
|
self:mixercommand({ "set", self.channel, self.step .. "-" })
|
|
end
|
|
|
|
function vcontrol:toggle()
|
|
self:mixercommand({ "set", self.channel, "toggle" })
|
|
end
|
|
|
|
function vcontrol:mute()
|
|
self:mixercommand({ "set", "Master", "mute" })
|
|
end
|
|
|
|
function vcontrol:unmute()
|
|
self:mixercommand({ "set", "Master", "unmute" })
|
|
end
|
|
|
|
function vcontrol:list_sinks(callback)
|
|
exec("env LC_ALL=C pactl list sinks", function(output)
|
|
local sinks = {}
|
|
local sink
|
|
for line in output:gmatch("[^\r\n]+") do
|
|
if line:match("Sink #%d+") then
|
|
sink = {}
|
|
table.insert(sinks, sink)
|
|
else
|
|
local k, v = line:match("^%s*(%S+):%s*(.-)%s*$")
|
|
if k and v then sink[k:lower()] = v end
|
|
end
|
|
end
|
|
callback(sinks)
|
|
end)
|
|
end
|
|
|
|
function vcontrol:set_default_sink(name, callback)
|
|
exec({"pactl set-default-sink", name}, callback)
|
|
end
|
|
|
|
------------------------------------------
|
|
-- Volume control widget
|
|
------------------------------------------
|
|
|
|
-- derive so that users can still call up/down/mute etc
|
|
local vwidget = class(vcontrol)
|
|
|
|
function vwidget:init(args)
|
|
vcontrol.init(self, args)
|
|
|
|
self.lclick = args.lclick or "toggle"
|
|
self.mclick = args.mclick or "pavucontrol"
|
|
self.rclick = args.rclick or self.show_menu
|
|
|
|
self.font = args.font or nil
|
|
self.widget = args.widget or (self:create_widget(args) or self.widget)
|
|
self.tooltip = args.tooltip and (self:create_tooltip(args) or self.tooltip)
|
|
|
|
self:register(args.callback or self.update_widget)
|
|
self:register(args.tooltip and self.update_tooltip)
|
|
|
|
self.widget:buttons(awful.util.table.join(
|
|
awful.button({}, 1, function() self:action(self.lclick) end),
|
|
awful.button({}, 2, function() self:action(self.mclick) end),
|
|
awful.button({}, 3, function() self:action(self.rclick) end),
|
|
awful.button({}, 4, function() self:up() end),
|
|
awful.button({}, 5, function() self:down() end)
|
|
))
|
|
|
|
self:get()
|
|
end
|
|
|
|
-- text widget
|
|
function vwidget:create_widget(args)
|
|
self.widget_text = args.widget_text or {
|
|
on = '% 3d%% ',
|
|
off = '% 3dM ',
|
|
}
|
|
self.widget = wibox.widget.textbox()
|
|
if self.font then
|
|
self.widget.font = self.font
|
|
end
|
|
end
|
|
|
|
function vwidget:create_menu(callback)
|
|
self:list_sinks(function(sinks)
|
|
local sinks_submenu = {}
|
|
for i, sink in ipairs(sinks) do
|
|
table.insert(sinks_submenu, {sink.description, function()
|
|
self:set_default_sink(sink.name)
|
|
end})
|
|
end
|
|
callback(awful.menu { items = {
|
|
{ "mute", function() self:mute() end },
|
|
{ "unmute", function() self:unmute() end },
|
|
{ "Default Sink", sinks_submenu },
|
|
{ "pavucontrol", function() self:action("pavucontrol") end },
|
|
} })
|
|
end)
|
|
end
|
|
|
|
function vwidget:show_menu()
|
|
if self.menu then
|
|
self.menu:hide()
|
|
else
|
|
self:create_menu(function(menu)
|
|
self.menu = menu
|
|
self.menu:show()
|
|
self.menu.wibox:connect_signal("property::visible", function()
|
|
self.menu = nil
|
|
end)
|
|
end)
|
|
end
|
|
end
|
|
|
|
function vwidget:update_widget(setting)
|
|
self.widget:set_markup(
|
|
self.widget_text[setting.state]:format(setting.volume))
|
|
end
|
|
|
|
-- tooltip
|
|
function vwidget:create_tooltip(args)
|
|
self.tooltip_text = args.tooltip_text or [[
|
|
Volume: ${volume}% ${state}
|
|
Channel: ${channel}
|
|
Device: ${device}
|
|
Card: ${card}]]
|
|
self.tooltip = args.tooltip and awful.tooltip({objects={self.widget}})
|
|
end
|
|
|
|
function vwidget:update_tooltip(setting)
|
|
self.tooltip:set_text(substitute(self.tooltip_text, {
|
|
volume = setting.volume,
|
|
state = setting.state,
|
|
device = self.device,
|
|
card = self.card,
|
|
channel = self.channel,
|
|
}))
|
|
end
|
|
|
|
-- provide direct access to the control class
|
|
vwidget.control = vcontrol
|
|
return vwidget
|