Crylia/crylia-theme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

a lot of stuff and added dbus_proxy as sub module

Browse Source
This commit is contained in:
Rene
2022-09-12 21:16:19 +02:00
parent e5cdb33eec
commit 3d8b240ef0
26 changed files with 1730 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
awesome/src/tools/auto_starter.lua
View File

@@ -1,7 +1,20 @@
local awful = require("awful")
local Gio = require("lgi").Gio
local gears = require("gears")
return function(table)
for _, t in ipairs(table) do
awful.spawn(t);
end
local path = gears.filesystem.get_xdg_config_home() .. "autostart/"
local handler = io.popen("ls " .. path)
if not handler then return end
for file in handler:lines() do
local app = Gio.DesktopAppInfo.new_from_filename(path .. file)
if app then
Gio.AppInfo.launch_uris_async(Gio.AppInfo.create_from_commandline(Gio.DesktopAppInfo.get_string(app,
"Exec"), nil, 0))
end
end
end

4
awesome/src/tools/gio_icon_lookup.lua
View File

@@ -39,9 +39,9 @@ function Get_icon(class, name)
local icon_string = Gio.DesktopAppInfo.get_string(desktop_app_info, "Icon")
if icon_string then
icon_string = string.lower(icon_string)
if icon_string:match(class) or class:match(icon_string) then
if icon_string == class or icon_string == name then
return Get_gicon_path(app_info.get_icon(app))
elseif icon_string:match(name) or name:match(icon_string) then
elseif icon_string:match(class) then
return Get_gicon_path(app_info.get_icon(app))
end
end

18
awesome/src/tools/helpers/audio.lua
View File

@@ -1,5 +1,23 @@
local awful = require("awful")
--[[ local lgi = require("lgi")
local pulseaudio = require("lua_libpulse_glib")
local ppretty = require("pl.ppretty")
local pa = pulseaudio.new()
local ctx = pa:context("My Test App")
ctx:connect(nil, function(state)
if state == 4 then
print("Connection is ready")
ctx:get_sinks(function(sinks)
ppretty.dump(sinks)
end)
end
end) ]]
awful.spawn.with_line_callback(
[[bash -c "LC_ALL=C pactl subscribe"]],
{

6
awesome/src/tools/helpers/cpu_usage.lua
View File

@@ -4,12 +4,13 @@ local watch = awful.widget.watch
local total_prev = 0
local idle_prev = 0
--!Find a better way that doesn't need manual GC since it has a huge performance impact
watch(
[[ cat "/proc/stat" | grep '^cpu ' ]],
3,
function(_, stdout)
local user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice =
stdout:match("(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s")
local user, nice, system, idle, iowait, irq, softirq, steal =
stdout:match("(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s(%d+)%s")
local total = user + nice + system + idle + iowait + irq + softirq + steal
@@ -21,6 +22,7 @@ watch(
total_prev = total
idle_prev = idle
collectgarbage("collect")
end
)

5
awesome/src/tools/helpers/init.lua
View File

@@ -1,8 +1,9 @@
require("src.tools.helpers.cpu_temp")
require("src.tools.helpers.cpu_usage")
--!Find a better way that doesn't need manual GC since it has a huge performance impact
--require("src.tools.helpers.cpu_usage")
require("src.tools.helpers.cpu_freq")
require("src.tools.helpers.ram")
require("src.tools.helpers.gpu_usage")
require("src.tools.helpers.gpu_temp")
require("src.tools.helpers.audio")
--require("src.tools.helpers.backlight")
require("src.tools.helpers.backlight")

345
awesome/src/tools/helpers/playerctl.lua Normal file
View File

@@ -0,0 +1,345 @@
-- 99.9% Stolen from bling
local gobject = require("gears.object")
local gtable = require("gears.table")
local gtimer = require("gears.timer")
local gstring = require("gears.string")
local playerctl = { mt = {} }
playerctl._private = {}
function playerctl:play_pause(player)
player = player or self._private.manager.players[1]
if player then
player:play_pause()
end
end
function playerctl:next(player)
player = player or self._private.manager.players[1]
if player then
player:next()
end
end
function playerctl:previous(player)
player = player or self._private.manager.players[1]
if player then
player:previous()
end
end
function playerctl:cycle_loop(player)
player = player or self._private.manager.players[1]
if player then
local loop_status = player.loop_status
if loop_status == "NONE" then
player:set_loop_status("TRACK")
elseif loop_status == "TRACK" then
player:set_loop_status("PLAYLIST")
elseif loop_status == "PLAYLIST" then
player:set_loop_status("NONE")
end
end
end
function playerctl:cycle_shuffle(player)
player = player or self._private.manager.players[1]
if player then
player:set_shuffle(not player.shuffle)
end
end
function playerctl:set_position(position, player)
player = player or self._private.manager.players[1]
if player then
player:set_position(position * 1000000)
end
end
function playerctl:get_manager()
return self._private.manager
end
function playerctl:get_current_player()
return self._private.manager.players[1].name
end
local function emit_metadata_callback(self, title, artist, art_url, album, new, player_name)
title = gstring.xml_escape(title)
artist = gstring.xml_escape(artist)
album = gstring.xml_escape(album)
if player_name == "spotify" then
art_url = art_url:gsub("open.spotify.com", "i.scdn.co")
end
if not art_url or art_url == "" then
else
awesome.emit_signal("playerctl::title_artist_album", title, artist, "", player_name)
self:emit_signal("metadata", title, artist, "", album, new, player_name)
end
end
local function metadata_callback(self, player, metadata)
if self.update_on_activity then
self._private.manager:mover_player_to_front(player)
end
local data = metadata.value
local title = data["xesam:title"] or ""
local artist = data["xesam:artist"] or ""
for i = 2, #data["xesam:artist"] do
artist = artist .. ", " .. data["xesam:artist"][i]
end
local art_url = data["mpris:artUrl"] or ""
local album = data["xesam:album"] or ""
if player == self._private.manager.players[1] then
if (not player == self._private.last_player) or (not title == self._private.manager.last_title) or
(not artist == self._private.manager.last_artist) or (not art_url == self._private.manager.last_art_url) then
if (title == "") and (artist == "") and (art_url == "") then return end
if (not self._private.metadata_timer) and self._private.metadata_timer.started then
self._private.metadata_timer:stop()
end
self._private.metadata_timer = gtimer {
timeout = 1,
autostart = true,
single_shot = true,
callback = function()
emit_metadata_callback(self, title, artist, art_url, album, true, player.name)
end
}
self._private.manager.pos_timer:again()
self._private.manager.last_title = title
self._private.manager.last_artist = artist
self._private.manager.last_art_url = art_url
self._private.last_player = player
end
end
end
local function pos_callback(self)
local player = self._private.manager.players[1]
if player then
local pos = player:get_position() / 1000000
local dur = (player.metadata.value["mpris:length"] or 0) / 1000000
if (not pos == self._private.last_pos) or (not dur == self._private.last_length) then
self._private.pos = pos
self._private.dur = dur
self:emit_signal("position", pos, dur, player.player_name)
end
end
end
local function playback_status_callback(self, player, status)
if self.update_on_activity then
self._private.manager:mover_player_to_front(player)
end
if player == self._private.manager.players[1] then
self._private.active_player = player
if status == "PLAYING" then
self:emit_signal("playerctl::playback_status", true, player.player_name)
awesome.emit_signal("playerctl::playback_status", true, player.player_name)
else
self:emit_signal("playerctl::playback_status", false, player.player_name)
awesome.emit_signal("playerctl::playback_status", false, player.player_name)
end
end
end
local function loop_callback(self, player, loop_status)
if self.update_on_activity then
self._private.manager:mover_player_to_front(player)
end
if player == self._private.manager.players[1] then
self._private.active_player = player
self:emit_signal("loop_status", loop_status, player.player_name)
end
end
local function shuffle_callback(self, player, shuffle)
if self.update_on_activity then
self._private.manager:mover_player_to_front(player)
end
if player == self._private.manager.players[1] then
self._private.active_player = player
self:emit_signal("shuffle", shuffle, player.player_name)
end
end
local function exit_callback(self, player)
if player == self._private.manager.players[1] then
self:emit_signal("playerctl::exit", player.player_name)
end
end
local function name_is_selected(self, name)
if self.ignore[name.name] then
return false
end
if self.priority > 0 then
for _, arg in pairs(self.priority) do
if arg == name.name or arg == "%any" then
return true
end
end
return false
end
end
local function init_player(self, name)
if name_is_selected(self, name) then
local player = self._private.Playerctl.Player.new_from_name(name)
self._private.manager:manage_player(player)
player.on_metadata = function(p, m)
metadata_callback(self, p, m)
end
player.on_playback_status = function(p, s)
playback_status_callback(self, p, s)
end
player.on_loop_status = function(p, s)
loop_callback(self, p, s)
end
player.on_shuffle = function(p, s)
shuffle_callback(self, p, s)
end
player.on_exit = function(p)
exit_callback(self, p)
end
if not self._private.pos_timer.started then
self._private.pos_timer:start()
end
end
end
local function player_compare(self, a, b)
local player_a = self._private.Playerctl.Player(a)
local player_b = self._private.Playerctl.Player(b)
local i = math.huge
local ai = nil
local bi = nil
if player_a == player_b then
return 0
end
for index, name in ipairs(self.priority) do
if name == "%any" then
i = (i == math.huge) and index or i
elseif name == player_a.player_name then
ai = ai or index
elseif name == player_b.player_name then
bi = bi or index
end
end
if not ai and not bi then
return 0
elseif not ai then
return (bi < i) and 1 or -1
elseif not bi then
return (ai < i) and -1 or 1
elseif ai == bi then
return 0
else
return (ai < bi) and -1 or 1
end
end
local function get_current_player(self, player)
local title = player:get_title() or "Unknown"
local artist = player:get_artist() or "Unknown"
local album = player:get_album() or "Unknown"
local art_url = player:print_metadata_prop("mpris:artUtl") or ""
emit_metadata_callback(self, title, artist, art_url, album, false, player.player_name)
playback_status_callback(self, player, player.playback_status)
loop_callback(self, player, player.loop_status)
end
local function start_manager(self)
self._private.manager = self.private.Playerctl.PlayerManager()
if #self.priority > 0 then
self._private.manager:set_sort_func(function(a, b)
return player_compare(self, a, b)
end)
end
self._private.pos_timer = gtimer {
timeout = 1,
callback = function()
pos_callback(self)
end
}
for _, name in ipairs(self._private.manager.player_names) do
init_player(self, name)
end
if self._private.manager.players[1] then
get_current_player(self, self._private.manager.players[1])
end
local _self = self
function self._private.manager:on_name_appeared(name)
init_player(_self, name)
end
function self._private.manager:on_player_appeared(player)
if player == self.players[1] then
_self._private.active_player = player
end
end
function self._private.manager:on_player_vanished(player)
if #self.players == 0 then
_self._private.metadata_timer:stop()
_self._private.pos_timer:stop()
_self:emit_signal("playerctl::noplayers")
awesome.emit_signal("playerctl::noplayers")
elseif player == _self._private.active_player then
_self._private.active_player = self.players[1]
get_current_player(_self, _self._private.active_player)
end
end
end
function playerctl.new(args)
args = args or {}
local ret = gobject {}
gtable.crush(ret, playerctl, true)
ret.update_on_activity = true
ret.interval = 1
ret._private = {}
ret._private.Playerctl = require("lgi").Playerctl
ret._private.manager = nil
gtimer.delayed_call(function()
start_manager(ret)
end)
return ret
end
function playerctl.mt:__call(...)
return playerctl.new(...)
end
return setmetatable(playerctl, playerctl.mt)

131
awesome/src/tools/ical_parser.lua
View File

@@ -1,6 +1,14 @@
local ical = {}
local gfilesystem = require("gears.filesystem")
local gobject = require("gears.object")
local gtable = require("gears.table")
local naughty = require("naughty")
local json = require("src.lib.json-lua.json-lua")
local ical = { mt = {} }
ical.VCALENDAR = {}
ical._private = {}
ical._private.cache = {}
ical._private.parser = {}
--[[
@@ -63,24 +71,74 @@ ical._private.parser = {}
DTSTAMP = "...",
]]
---Takes a path to an .ical file then parses it into a lua table and returns it
---@param path string Path to the .ical file
---@return table | nil calendar New calendar table or nil on error
function ical.new(path)
local handler = io.open(path, "r")
function ical._private.add_to_cache(file, vcal)
-- Copy file to src/config/files/calendar/
local path = gfilesystem.get_configuration_dir() .. "src/config/"
local file_name = file:match(".*/(.*)")
if not
os.execute("cp " ..
file .. " " .. gfilesystem.get_configuration_dir() .. "src/config/files/calendar/" .. file_name) then
naughty.notification({
app_name = "Systemnotification",
title = "Error",
text = "Could not copy file to config/files/calendar/",
timeout = 0,
urgency = "critical",
})
return
end
local handler = io.open(path .. "calendar.json", "r")
if not handler then return end
local json_data = json:decode(handler:read("a"))
handler:close()
if not (type(json_data) == "table") then return end
table.insert(json_data, {
file = file_name,
VCALENDAR = vcal,
})
json_data = json:encode(json_data)
handler = io.open(path .. "calendar.json", "w")
if not handler then return end
handler:write(json_data)
handler:close()
end
function ical:add_calendar(file)
local handler = io.open(file, "r")
if not handler then return end
-- Check if the line is a BEGIN:VCALENDAR
local v, k = handler:read("l"):match("([A-Z]+):([A-Z]+)")
local vcal = {}
if v:match("BEGIN") and k:match("VCALENDAR") then
table.insert(ical.VCALENDAR, ical._private.parser.VCALENDAR(handler))
return ical
vcal = self._private.parser.VCALENDAR(handler)
table.insert(self.VCALENDAR, vcal)
self._private.add_to_cache(file, vcal)
end
end
function ical.new(args)
args = args or {}
local ret = gobject {}
gtable.crush(ret, ical, true)
local path = gfilesystem.get_configuration_dir() .. "src/config/calendar.json"
local handler = io.open(path, "r")
if not handler then return end
local json_data = json:decode(handler:read("a"))
handler:close()
if not (type(json_data) == "table") then return end
--Load into the cache
for _, v in ipairs(json_data) do
ret._private.cache[v.file] = v.VCALENDAR
table.insert(ret.VCALENDAR, v.VCALENDAR)
end
return ical
end
function ical._private.parser.VEVENT(handler)
function ical._private.parser:VEVENT(handler)
local VEVENT = {}
while true do
@@ -92,11 +150,11 @@ function ical._private.parser.VEVENT(handler)
local v, k = line:match("(.*):(.*)")
if v:match("CREATED") then
VEVENT.CREATED = ical._private.parser.to_datetime(k)
VEVENT.CREATED = self._private.parser.to_datetime(k)
elseif v:match("LAST-MODIFIED") then
VEVENT.LAST_MODIFIED = ical._private.parser.to_datetime(k)
VEVENT.LAST_MODIFIED = self._private.parser.to_datetime(k)
elseif v:match("DTSTAMP") then
VEVENT.DTSTAMP = ical._private.parser.to_datetime(k)
VEVENT.DTSTAMP = self._private.parser.to_datetime(k)
elseif v:match("UID") then
VEVENT.UID = k
elseif v:match("SUMMARY") then
@@ -104,20 +162,20 @@ function ical._private.parser.VEVENT(handler)
elseif v:match("RRULE") then
VEVENT.RRULE = {
FREQ = k:match("FREQ=([A-Z]+)"),
UNTIL = ical._private.parser.to_datetime(k:match("UNTIL=([TZ0-9]+)")),
UNTIL = self._private.parser.to_datetime(k:match("UNTIL=([TZ0-9]+)")),
WKST = k:match("WKST=([A-Z]+)"),
COUNT = k:match("COUNT=([0-9]+)"),
INTERVAL = k:match("INTERVAL=([0-9]+)")
}
elseif v:match("DTSTART") then
VEVENT.DTSTART = {
DTSTART = ical._private.parser.to_datetime(k),
DTSTART = self._private.parser.to_datetime(k),
TZID = v:match("TZID=([a-zA-Z-\\/]+)"),
VALUE = v:match("VALUE=([A-Z]+)")
}
elseif v:match("DTEND") then
VEVENT.DTEND = {
DTEND = ical._private.parser.to_datetime(k),
DTEND = self._private.parser.to_datetime(k),
TZID = v:match("TZID=([a-zA-Z-\\/]+)"),
VALUE = v:match("VALUE=([A-Z]+)")
}
@@ -134,11 +192,12 @@ function ical._private.parser.VEVENT(handler)
}
elseif v:match("BEGIN") then
if k:match("VALARM") then
VEVENT.VALARM = ical._private.parser.VALARM(handler)
VEVENT.VALARM = self._private.parser:VALARM(handler)
end
elseif v:match("UID") then
VEVENT.UID = k
end
end
--VEVENT.duration = VEVENT.DTSTART.DTSTART - VEVENT.DTEND.DTEND
return VEVENT
@@ -153,7 +212,7 @@ function ical._private.parser.alarm_to_time(alarm)
return time .. unit
end
function ical._private.parser.VALARM(handler)
function ical._private.parser:VALARM(handler)
local VALARM = {}
while true do
@@ -169,7 +228,7 @@ function ical._private.parser.VALARM(handler)
elseif v:match("TRIGGER;VALUE=DURATION") then
VALARM.TRIGGER = {
VALUE = v:match("VALUE=(.*):"),
TRIGGER = ical._private.parser.alarm_to_time(k)
TRIGGER = self._private.parser.alarm_to_time(k)
}
elseif v:match("DESCRIPTION") then
VALARM.DESCRIPTION = k
@@ -179,7 +238,7 @@ function ical._private.parser.VALARM(handler)
return VALARM
end
function ical._private.parser.VCALENDAR(handler)
function ical._private.parser:VCALENDAR(handler)
local VCALENDAR = {}
VCALENDAR.VEVENT = {}
VCALENDAR.VTIMEZONE = {}
@@ -199,9 +258,9 @@ function ical._private.parser.VCALENDAR(handler)
VCALENDAR.VERSION = k
elseif v:match("BEGIN") then
if k:match("VTIMEZONE") then
VCALENDAR.VTIMEZONE = ical._private.parser.VTIMEZONE(handler)
VCALENDAR.VTIMEZONE = self._private.parser:VTIMEZONE(handler)
elseif k:match("VEVENT") then
table.insert(VCALENDAR.VEVENT, ical._private.parser.VEVENT(handler))
table.insert(VCALENDAR.VEVENT, self._private.parser:VEVENT(handler))
end
end
end
@@ -211,7 +270,7 @@ function ical._private.parser.VCALENDAR(handler)
return VCALENDAR
end
function ical._private.parser.VTIMEZONE(handler)
function ical._private.parser:VTIMEZONE(handler)
local VTIMEZONE = {}
while true do
@@ -227,9 +286,9 @@ function ical._private.parser.VTIMEZONE(handler)
end
if v:match("BEGIN") then
if k:match("DAYLIGHT") then
VTIMEZONE.DAYLIGHT = ical._private.parser.DAYLIGHT(handler)
VTIMEZONE.DAYLIGHT = self._private.parser:DAYLIGHT(handler)
elseif k:match("STANDARD") then
VTIMEZONE.STANDARD = ical._private.parser.STANDARD(handler)
VTIMEZONE.STANDARD = self._private.parser:STANDARD(handler)
end
end
end
@@ -237,7 +296,7 @@ function ical._private.parser.VTIMEZONE(handler)
return VTIMEZONE
end
function ical._private.parser.DAYLIGHT(handler)
function ical._private.parser:DAYLIGHT(handler)
local DAYLIGHT = {}
while true do
@@ -249,13 +308,13 @@ function ical._private.parser.DAYLIGHT(handler)
local v, k = line:match("(.*):(.*)")
if v:match("TZOFFSETFROM") then
DAYLIGHT.TZOFFSETFROM = ical._private.parser.offset(k)
DAYLIGHT.TZOFFSETFROM = self._private.parser.offset(k)
elseif v:match("TZOFFSETTO") then
DAYLIGHT.TZOFFSETTO = ical._private.parser.offset(k)
DAYLIGHT.TZOFFSETTO = self._private.parser.offset(k)
elseif v:match("TZNAME") then
DAYLIGHT.TZNAME = k
elseif v:match("DTSTART") then
DAYLIGHT.DTSTART = ical._private.parser.to_datetime(k)
DAYLIGHT.DTSTART = self._private.parser.to_datetime(k)
elseif v:match("RRULE") then
DAYLIGHT.RRULE = {
FREQ = k:match("FREQ=([A-Z]+)"),
@@ -271,7 +330,7 @@ end
---Parses the STANDARD property into a table
---@param handler table
---@return table STANDARD The STANDARD property as a table
function ical._private.parser.STANDARD(handler)
function ical._private.parser:STANDARD(handler)
local STANDARD = {}
-- Read each line until END:STANDARD is read
@@ -285,13 +344,13 @@ function ical._private.parser.STANDARD(handler)
-- Break down each line into the property:value
local v, k = line:match("(.*):(.*)")
if v:match("TZOFFSETFROM") then
STANDARD.TZOFFSETFROM = ical._private.parser.offset(k)
STANDARD.TZOFFSETFROM = self._private.parser.offset(k)
elseif v:match("TZOFFSETTO") then
STANDARD.TZOFFSETTO = ical._private.parser.offset(k)
STANDARD.TZOFFSETTO = self._private.parser.offset(k)
elseif v:match("TZNAME") then
STANDARD.TZNAME = k
elseif v:match("DTSTART") then
STANDARD.DTSTART = ical._private.parser.to_datetime(k)
STANDARD.DTSTART = self._private.parser.to_datetime(k)
elseif v:match("RRULE") then
STANDARD.RRULE = {
FREQ = k:match("FREQ=([A-Z]+)"),
@@ -329,4 +388,8 @@ function ical._private.parser.offset(offset)
return s * (tonumber(h) * 3600 + tonumber(m) * 60)
end
return ical
function ical.mt:__call(...)
return ical.new(...)
end
return setmetatable(ical, ical.mt)