From 2c72f6c94141cb5b9d95fd027ae65f76880aba07 Mon Sep 17 00:00:00 2001 From: don-philipe Date: Mon, 15 Feb 2016 21:13:41 +0100 Subject: [PATCH] init files and helper added --- helpers.lua | 25 +++++ init.lua | 259 +++++++++++++++++++++++++++++++++++++++++++++++ widgets/init.lua | 7 ++ 3 files changed, 291 insertions(+) create mode 100644 helpers.lua create mode 100644 init.lua create mode 100644 widgets/init.lua diff --git a/helpers.lua b/helpers.lua new file mode 100644 index 0000000..515f1b7 --- /dev/null +++ b/helpers.lua @@ -0,0 +1,25 @@ +-- some things copied from vicious' helper + +local rawget = rawget +local helpers = {} + +-- {{{ Loader for knorke modules +function helpers.wrequire(table, key) + local module = rawget(table, key) + return module or require(table._NAME .. "." .. key) +end +-- }}} + +-- {{ Format a string with args +function helpers.format(format, args) + for var, val in pairs(args) do + format = format:gsub("$" .. (tonumber(var) and var or + var:gsub("[-+?*]", function(i) return "%"..i end)), + val) + end + + return format +end +-- }}} + +return helpers diff --git a/init.lua b/init.lua new file mode 100644 index 0000000..9dbb80b --- /dev/null +++ b/init.lua @@ -0,0 +1,259 @@ +-- copied from vicious' init.lua +-- {{{ Setup environment +local type = type +local pairs = pairs +local tonumber = tonumber +local timer = (type(timer) == 'table' and timer or require("gears.timer")) +local os = { time = os.time } +local table = { + insert = table.insert, + remove = table.remove +} + +local helpers = require("knorke.helpers") + +-- knorke: widgets for the awesome window manager +local knorke = {} +knorke.widgets = require("knorke.widgets") +--knorke.contrib = require("knorke.contrib") + +-- Initialize tables +local timers = {} +local registered = {} +local widget_cache = {} +-- }}} + + +-- {{{ Local functions +-- {{{ Update a widget +local function update(widget, reg, disablecache) + -- Check if there are any equal widgets + if reg == nil then + for w, i in pairs(registered) do + if w == widget then + for _, r in pairs(i) do + update(w, r, disablecache) + end + end + end + + return + end + + local t = os.time() + local data = {} + + -- Check for chached output newer than the last update + if widget_cache[reg.wtype] ~= nil then + local c = widget_cache[reg.wtype] + + if (c.time == nil or c.time <= t-reg.timer) or disablecache then + c.time, c.data = t, reg.wtype(reg.format, reg.warg) + end + + data = c.data + else + data = reg.wtype and reg.wtype(reg.format, reg.warg) + end + + if type(data) == "table" then + if type(reg.format) == "string" then + data = helpers.format(reg.format, data) + elseif type(reg.format) == "function" then + data = reg.format(widget, data) + end + end + + if widget.add_value ~= nil then + widget:add_value(tonumber(data) and tonumber(data)/100) + elseif widget.set_value ~= nil then + widget:set_value(tonumber(data) and tonumber(data)/100) + elseif widget.set_markup ~= nil then + widget:set_markup(data) + else + widget.text = data + end + + return data +end +-- }}} + +-- {{{ Register from reg object +local function regregister(reg) + if not reg.running then + if registered[reg.widget] == nil then + registered[reg.widget] = {} + table.insert(registered[reg.widget], reg) + else + local already = false + + for w, i in pairs(registered) do + if w == reg.widget then + for _, v in pairs(i) do + if v == reg then + already = true + break + end + end + + if already then + break + end + end + end + + if not already then + table.insert(registered[reg.widget], reg) + end + end + + -- Start the timer + if reg.timer > 0 then + local tm = timers[reg.timer] and timers[reg.timer].timer + tm = tm or timer({ timeout = reg.timer }) + if tm.connect_signal then + tm:connect_signal("timeout", reg.update) + else + tm:add_signal("timeout", reg.update) + end + if not timers[reg.timer] then + timers[reg.timer] = { timer = tm, refs = 1 } + else + timers[reg.timer].refs = timers[reg.timer].refs + 1 + end + if not tm.started then + tm:start() + end + -- Initial update + reg.update() + end + reg.running = true + end +end +-- }}} +-- }}} + + +-- {{{ Global functions +-- {{{ Register a widget +function knorke.register(widget, wtype, format, timer, warg) + local widget = widget + local reg = { + -- Set properties + wtype = wtype, + format = format, + timer = timer, + warg = warg, + widget = widget, + } + -- Set functions + reg.update = function () + update(widget, reg) + end + + -- Default to 2s timer + if reg.timer == nil then + reg.timer = 2 + end + + -- Register a reg object + regregister(reg) + + -- Return a reg object for reuse + return reg +end +-- }}} + +-- {{{ Unregister a widget +function knorke.unregister(widget, keep, reg) + if reg == nil then + for w, i in pairs(registered) do + if w == widget then + for _, v in pairs(i) do + reg = knorke.unregister(w, keep, v) + end + end + end + + return reg + end + + if not keep then + for w, i in pairs(registered) do + if w == widget then + for k, v in pairs(i) do + if v == reg then + table.remove(registered[w], k) + end + end + end + end + end + + if not reg.running then + return reg + end + + -- Disconnect from timer + local tm = timers[reg.timer] + if tm.timer.disconnect_signal then + tm.timer:disconnect_signal("timeout", reg.update) + else + tm.timer:remove_signal("timeout", reg.update) + end + reg.running = false + -- Stop the timer + tm.refs = tm.refs - 1 + if tm.refs == 0 and tm.timer.started then + tm.timer:stop() + end + + return reg +end +-- }}} + +-- {{{ Enable caching of a widget type +function knorke.cache(wtype) + if wtype ~= nil then + if widget_cache[wtype] == nil then + widget_cache[wtype] = {} + end + end +end +-- }}} + +-- {{{ Force update of widgets +function knorke.force(wtable) + if type(wtable) == "table" then + for _, w in pairs(wtable) do + update(w, nil, true) + end + end +end +-- }}} + +-- {{{ Suspend all widgets +function knorke.suspend() + for w, i in pairs(registered) do + for _, v in pairs(i) do + knorke.unregister(w, true, v) + end + end +end +-- }}} + +-- {{{ Activate a widget +function knorke.activate(widget) + for w, i in pairs(registered) do + if widget == nil or w == widget then + for _, v in pairs(i) do + regregister(v) + end + end + end +end +-- }}} + +return knorke + +-- }}} diff --git a/widgets/init.lua b/widgets/init.lua new file mode 100644 index 0000000..6cd04e9 --- /dev/null +++ b/widgets/init.lua @@ -0,0 +1,7 @@ +local setmetatable = setmetatable +local wrequire = require("knorke.helpers").wrequire + +local widgets = { _NAME = "knorke.widgets" } + +-- Load modules at runtime as needed +return setmetatable(contrib, { __index = wrequire })