162 lines
4.2 KiB
Lua
162 lines
4.2 KiB
Lua
-- TODO: Turn into App class
|
|
|
|
local module = {
|
|
apps = {},
|
|
bindings = {},
|
|
|
|
ls = function(directory)
|
|
local i, t, popen = 0, {}, io.popen
|
|
for filename in popen('ls -a "'..directory..'"'):lines() do
|
|
i = i + 1
|
|
t[i] = filename
|
|
end
|
|
return t
|
|
end,
|
|
|
|
reload = function()
|
|
hs.reload()
|
|
hs.alert("Config reloaded!")
|
|
end,
|
|
|
|
call = function(obj, fn)
|
|
return function () return obj[fn](obj) end
|
|
end,
|
|
|
|
autoimport = function(dir)
|
|
for _, file in pairs(util.ls(dir)) do
|
|
if file:find(".+%.lua") then
|
|
local a = string.gsub(file, '%.lua', '')
|
|
print(a .. " loaded")
|
|
require(dir .. "/" .. a)
|
|
end
|
|
end
|
|
end
|
|
}
|
|
|
|
-- App-specific code, runs when you launch or switch to another app
|
|
local apps = {}
|
|
App = {}
|
|
App.new = function(name)
|
|
local self = {}
|
|
self.name = name
|
|
self.bindings = {}
|
|
|
|
self.onInitFn = nil
|
|
self.onActivateFn = nil
|
|
self.onDeactivateFn = nil
|
|
self.onLaunchedFn = nil
|
|
self.onTerminatedFn = nil
|
|
|
|
self.bind = function(mods, key, action, predicate)
|
|
table.insert(self.bindings,
|
|
{key = hs.hotkey.new(mods, key, action), predicate = predicate})
|
|
return self
|
|
end
|
|
|
|
self.onInit = function(fn)
|
|
fn(self)
|
|
return self
|
|
end
|
|
self.onActivate = function(fn)
|
|
self.onActivateFn = fn
|
|
return self
|
|
end
|
|
self.onDeactivate = function(fn)
|
|
self.onDeactivateFn = fn
|
|
return self
|
|
end
|
|
self.onLaunched = function(fn)
|
|
self.onLaunchedFn = fn
|
|
return self
|
|
end
|
|
self.onTerminated = function(fn)
|
|
self.onTerminatedFn = fn
|
|
return self
|
|
end
|
|
|
|
self.activate = function(appObject)
|
|
if type(self.onActivateFn) == 'function' then
|
|
self:onActivateFn(appObject)
|
|
end
|
|
self:enableBinds()
|
|
end
|
|
self.deactivate = function(appObject)
|
|
if type(self.onDeactivateFn) == 'function' then
|
|
self:onDeactivateFn(appObject)
|
|
end
|
|
self:disableBinds()
|
|
end
|
|
self.launch = function(appObject)
|
|
if type(self.onLaunchedFn) == 'function' then
|
|
self:onLaunchedFn(appObject)
|
|
end
|
|
end
|
|
self.terminate = function(appObject)
|
|
if type(self.onTerminatedFn) == 'function' then
|
|
self:onTerminatedFn(appObject)
|
|
end
|
|
self:clearBinds()
|
|
end
|
|
|
|
self.enableBinds = function(self)
|
|
hs.fnutils.each(self.bindings, function(b)
|
|
if b.predicate and not b.predicate() then
|
|
b.key:disable()
|
|
else
|
|
b.key:enable()
|
|
end
|
|
end)
|
|
end
|
|
|
|
self.disableBinds = function(self)
|
|
hs.fnutils.each(self.bindings, function(b) b.key:disable() end)
|
|
end
|
|
|
|
self.clearBinds = function(self)
|
|
hs.fnutils.each(self.bindings, function(b) b.key:delete() end)
|
|
self.bindings = {}
|
|
end
|
|
|
|
apps[name] = self
|
|
return self
|
|
end
|
|
|
|
function invoke(keys, predicate)
|
|
return function ()
|
|
if predicate and not predicate() then
|
|
return
|
|
end
|
|
if type(keys) == 'table' then
|
|
hs.fnutils.each(keys, function (key)
|
|
if type(key) ~= 'table' then
|
|
key = {{}, key}
|
|
end
|
|
hs.eventtap.keyStroke(key[1], key[2])
|
|
end)
|
|
elseif type(keys) == 'string' then
|
|
os.execute(keys)
|
|
elseif type(keys) == 'function' then
|
|
return keys()
|
|
end
|
|
end
|
|
end
|
|
|
|
--
|
|
function appGlobalWatcher(appName, eventType, appObject)
|
|
if apps[appName] then
|
|
if (eventType == hs.application.watcher.activated) then
|
|
apps[appName].activate(appObject)
|
|
elseif (eventType == hs.application.watcher.deactivated) then
|
|
apps[appName].deactivate(appObject)
|
|
elseif (eventType == hs.application.watcher.launched) then
|
|
apps[appName].launch(appObject)
|
|
elseif (eventType == hs.application.watcher.terminated) then
|
|
apps[appName].terminate(appObject)
|
|
end
|
|
end
|
|
end
|
|
hs.application.watcher.new(appGlobalWatcher):start()
|
|
|
|
--
|
|
return module
|