Dump nixos config after scrubing

home-modules/explicit-configs/awesome/deficient/volume-control/volume-control.lua

@@ -0,0 +1,262 @@
+-- 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