"))
45 | targetTopLeft = targetWindow:topLeft()
46 | else
47 | alert("no window at current mouse location")
48 | end
49 | elseif receivedEvent == eventTypes.otherMouseUp then
50 | targetWindow = nil
51 | elseif receivedEvent == eventTypes.otherMouseDragged then
52 | if targetWindow then
53 | local dx = event:getProperty(eventProps.mouseEventDeltaX)
54 | local dy = event:getProperty(eventProps.mouseEventDeltaY)
55 | targetTopLeft = { x = targetTopLeft.x + dx, y = targetTopLeft.y + dy }
56 | targetWindow:setTopLeft(targetTopLeft)
57 | end
58 | else
59 | -- this should never happen
60 | alert("unexpected event: " .. (eventTypes[receivedEvent] or ("eventID " .. tostring(receivedEvent))))
61 | return false
62 | end
63 | return true
64 | else
65 | return false
66 | end
67 | end):start()
68 |
--------------------------------------------------------------------------------
/_scratch/patternMatch.lua:
--------------------------------------------------------------------------------
1 | -- from https://gist.github.com/heptal/7e578c3129012f0e7e91965bb1f2010e
2 |
3 | local name = "id"..hs.host.uuid():gsub("-","");
4 |
5 | local html = [[
6 |
7 | . all characters
8 | %a letters
9 | %b balanced delimiters
10 | %c control characters
11 | %d digits
12 | %l lower case letters
13 | %p punctuation characters
14 | %s space characters
15 | %u upper case letters
16 | %w alphanumeric characters
17 | %x hexadecimal digits
18 | %z the character with representation 0
19 | Evaluate pattern
25 | ]]
26 |
27 | local js = [[
28 | function sendData() {
29 | webkit.messageHandlers.]]..name..[[.postMessage({
30 | pattern: document.getElementById("pattern").value,
31 | text: document.getElementById("text").value
32 | })
33 | }
34 | ]]
35 |
36 | local css = [[
37 | input { width: 250px; }
38 | body {font-family: monospace;}
39 | span {background:rgba(0,0,200,0.2) }
40 | #response {font-size:11px}
41 | ]]
42 |
43 | local uc = hs.webview.usercontent.new(name):setCallback(function(input)
44 | local pattern, text = input.body.pattern, input.body.text;
45 | local result = text:gsub(pattern, function(s) return ''..s..' ' end)
46 | result = result:gsub("\n", "Hammerspoon link example
7 | @textblock/' \
38 | # -e 's/@endcode/@\/textblock<\/pre>/' \
39 | # -e 's/@remark/@attributeblock Notes/' LuaSkin/LuaSkin/Skin.h > Skin.h
40 | # headerdoc2html -u -o ${classDir} Skin.h
41 | # resolveLinks ${classDir}
42 | # mv ${classDir}/Skin_h/* ${classDir}
43 | # rmdir ${classDir}/Skin_h
44 | # rm Skin.h
45 |
46 | rm -fr ~/Documents/Hammerspoon
47 | mkdir ~/Documents/Hammerspoon
48 | mv build/Hammerspoon.docset ~/Documents/Hammerspoon/
49 | # mv build/html/LuaSkin ~/Documents/Hammerspoon/
50 | /usr/local/bin/appledoc \
51 | --project-name "LuaSkin" \
52 | --project-company "Hammerspoon" \
53 | --company-id "org.hammerspoon" \
54 | --output "build/LSDocs" \
55 | --clean-output \
56 | --no-install-docset \
57 | --no-publish-docset \
58 | --logformat xcode \
59 | --keep-undocumented-objects \
60 | --keep-undocumented-members \
61 | --keep-intermediate-files \
62 | --ignore "*.m" \
63 | LuaSkin/LuaSkin
64 | mv build/LSDocs/html ~/Documents/Hammerspoon/LuaSkin
65 | fi
66 |
67 | if [[ $1 != doc* ]]; then
68 | osascript -e 'tell Application "Hammerspoon" to quit'
69 | sleep 1
70 | rm -fr /Applications/_ASM_/Developer/Hammerspoon.app
71 | mv build/Hammerspoon.app /Applications/_ASM_/Developer/
72 |
73 | open -a /Applications/_ASM_/Developer/Hammerspoon.app
74 | fi
75 |
76 |
--------------------------------------------------------------------------------
/resources/timebg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asmagill/hammerspoon-config/432c65705203d7743d3298441bd4319137b466fd/resources/timebg.png
--------------------------------------------------------------------------------
/test.lua:
--------------------------------------------------------------------------------
1 | if not timelapsetopleft then timelapsetopleft = {980,400} end
2 |
3 | timelapsed_canvas = hs.canvas.new({x=timelapsetopleft[1],y=timelapsetopleft[2],w=280,h=125}):show()
4 | timelapsed_canvas:behavior(hs.canvas.windowBehaviors.canJoinAllSpaces)
5 | -- timelapsed_canvas:level(hs.canvas.windowLevels.desktopIcon)
6 | timelapsed_canvas:level(hs.canvas.windowLevels.screenSaver)
7 | -- canvas background
8 | timelapsed_canvas[1] = {
9 | action = "fill",
10 | type = "rectangle",
11 | fillColor = black,
12 | roundedRectRadii = {xRadius=5, yRadius=5},
13 | }
14 | timelapsed_canvas[1].fillColor.alpha = .2
15 | -- title
16 | timelapsed_canvas[2] = {
17 | type = "text",
18 | text = "Time Elapsed",
19 | textSize = 14,
20 | textColor = white,
21 | frame = {
22 | x = tostring(10/280),
23 | y = tostring(10/125),
24 | w = tostring(260/280),
25 | h = tostring(25/125),
26 | }
27 | }
28 | timelapsed_canvas[2].textColor.alpha = .3
29 | -- time
30 | timelapsed_canvas[3] = {
31 | type = "text",
32 | text = "",
33 | textColor = {hex="#A6AAC3"},
34 | textSize = 17,
35 | textAlignment = "center",
36 | frame = {
37 | x = tostring(0/280),
38 | y = tostring(35/125),
39 | w = tostring(280/280),
40 | h = tostring(25/125),
41 | }
42 | }
43 | -- indicator background
44 | timelapsed_canvas[4] = {
45 | type = "image",
46 | image = hs.image.imageFromPath("./resources/timebg.png"),
47 | frame = {
48 | x = tostring(10/280),
49 | y = tostring(65/125),
50 | w = tostring(260/280),
51 | h = tostring(50/125),
52 | }
53 | }
54 | -- light indicator
55 | timelapsed_canvas[5] = {
56 | action = "fill",
57 | type = "rectangle",
58 | fillColor = white,
59 | frame = {
60 | x = tostring(20/280),
61 | y = tostring(75/125),
62 | w = tostring(240/280),
63 | h = tostring(20/125),
64 | }
65 | }
66 | timelapsed_canvas[5].fillColor.alpha = .2
67 | -- indicator mask
68 | timelapsed_canvas[6] = {
69 | action = "fill",
70 | type = "rectangle",
71 | frame = {
72 | x = tostring(20/280),
73 | y = tostring(75/125),
74 | w = tostring(240/280),
75 | h = tostring(20/125),
76 | }
77 | }
78 | -- color indicator
79 | timelapsed_canvas[7] = {
80 | action = "fill",
81 | type = "rectangle",
82 | frame = {
83 | x = tostring(20/280),
84 | y = tostring(75/125),
85 | w = tostring(240/280),
86 | h = tostring(20/125),
87 | },
88 | fillGradient="linear",
89 | fillGradientColors = {
90 | {hex = "#00A0F7"},
91 | {hex = "#92D2E5"},
92 | {hex = "#4BE581"},
93 | {hex = "#EAF25E"},
94 | {hex = "#F4CA55"},
95 | {hex = "#E04E4E"},
96 | },
97 | }
98 | timelapsed_canvas[7].compositeRule = "sourceAtop"
99 |
100 | function updateElapsedCanvas()
101 | local nowtable = os.date("*t")
102 | local nowyday = nowtable.yday
103 | local nowhour = string.format("%2s", nowtable.hour)
104 | local nowmin = string.format("%2s", nowtable.min)
105 | local nowsec = string.format("%2s", nowtable.sec)
106 | local timestr = nowyday.." days "..nowhour.." hours "..nowmin.." min "..nowsec.." sec"
107 | local secs_since_epoch = os.time()
108 | local nowyear = nowtable.year
109 | local yearstartsecs_since_epoch = os.time({year=nowyear, month=1, day=1, hour=0})
110 | local nowyear_elapsed_secs = secs_since_epoch - yearstartsecs_since_epoch
111 | local yearendsecs_since_epoch = os.time({year=nowyear+1, month=1, day=1, hour=0})
112 | local nowyear_total_secs = yearendsecs_since_epoch - yearstartsecs_since_epoch
113 | local elapsed_percent = nowyear_elapsed_secs/nowyear_total_secs
114 | if timelapsed_canvas:isShowing() then
115 | timelapsed_canvas[3].text = timestr
116 | timelapsed_canvas[6].frame.w = tostring(240/280*elapsed_percent)
117 | end
118 |
119 | end
120 |
121 | if elapsedTimer == nil then
122 | elapsedTimer = hs.timer.doEvery(1, function() updateElapsedCanvas() end)
123 | else
124 | elapsedTimer:start()
125 | end
126 |
--------------------------------------------------------------------------------
/utils/_actions/annoyances.lua:
--------------------------------------------------------------------------------
1 | --
2 | -- Annoyances in hammerspoon functions/modules/whatever
3 | --
4 | -- Some of them were design decisions by me, some design decisions by others... in any case, they
5 | -- annoy me now, but not enough to make a huge deal about whether or not the actual module should
6 | -- be changed/updated.
7 | --
8 |
9 | local module = {}
10 |
11 | local settings = require("hs.settings")
12 |
13 | -- private variables and methods -----------------------------------------
14 |
15 | local _kMetaTable = {}
16 | _kMetaTable._k = setmetatable({}, {__mode = "k"})
17 | _kMetaTable._t = setmetatable({}, {__mode = "k"})
18 | _kMetaTable.__index = function(obj, key)
19 | if _kMetaTable._k[obj] then
20 | if _kMetaTable._k[obj][key] then
21 | return _kMetaTable._k[obj][key]
22 | else
23 | for k,v in pairs(_kMetaTable._k[obj]) do
24 | if v == key then return k end
25 | end
26 | end
27 | end
28 | return nil
29 | end
30 | _kMetaTable.__newindex = function(obj, key, value)
31 | error("attempt to modify a table of constants",2)
32 | return nil
33 | end
34 | _kMetaTable.__pairs = function(obj) return pairs(_kMetaTable._k[obj]) end
35 | _kMetaTable.__len = function(obj) return #_kMetaTable._k[obj] end
36 | _kMetaTable.__tostring = function(obj)
37 | local result = ""
38 | if _kMetaTable._k[obj] then
39 | local width = 0
40 | for k,v in pairs(_kMetaTable._k[obj]) do width = width < #tostring(k) and #tostring(k) or width end
41 | for k,v in require("hs.fnutils").sortByKeys(_kMetaTable._k[obj]) do
42 | if _kMetaTable._t[obj] == "table" then
43 | result = result..string.format("%-"..tostring(width).."s %s\n", tostring(k),
44 | ((type(v) == "table") and "{ table }" or tostring(v)))
45 | else
46 | result = result..((type(v) == "table") and "{ table }" or tostring(v)).."\n"
47 | end
48 | end
49 | else
50 | result = "constants table missing"
51 | end
52 | return result
53 | end
54 | _kMetaTable.__metatable = _kMetaTable -- go ahead and look, but don't unset this
55 |
56 | local _makeConstantsTable
57 | _makeConstantsTable = function(theTable)
58 | if type(theTable) ~= "table" then
59 | local dbg = debug.getinfo(2)
60 | local msg = dbg.short_src..":"..dbg.currentline..": attempting to make a '"..type(theTable).."' into a constant table"
61 | if module.log then module.log.ef(msg) else print(msg) end
62 | return theTable
63 | end
64 | for k,v in pairs(theTable) do
65 | if type(v) == "table" then
66 | local count = 0
67 | for a,b in pairs(v) do count = count + 1 end
68 | local results = _makeConstantsTable(v)
69 | if #v > 0 and #v == count then
70 | _kMetaTable._t[results] = "array"
71 | else
72 | _kMetaTable._t[results] = "table"
73 | end
74 | theTable[k] = results
75 | end
76 | end
77 | local results = setmetatable({}, _kMetaTable)
78 | _kMetaTable._k[results] = theTable
79 | local count = 0
80 | for a,b in pairs(theTable) do count = count + 1 end
81 | if #theTable > 0 and #theTable == count then
82 | _kMetaTable._t[results] = "array"
83 | else
84 | _kMetaTable._t[results] = "table"
85 | end
86 | return results
87 | end
88 |
89 | -- Public Changes ------------------------------------------------------
90 |
91 | if settings.keys then print("++ settings.keys already exists, skipping") else
92 | settings.keys = function()
93 | local results = {}
94 | for i,v in ipairs(hs.settings.getKeys()) do table.insert(results, v) end
95 | table.sort(results)
96 | return _makeConstantsTable(results)
97 | end
98 | end
99 |
100 | -- Return Module Object --------------------------------------------------
101 |
102 | return module
103 |
--------------------------------------------------------------------------------
/utils/_actions/battery_usbdrives.lua:
--------------------------------------------------------------------------------
1 | -- Try to unmount USB drives if we switch to battery, cause we're probably
2 | -- yanking the USB cable next...
3 |
4 | local battery = require("hs.battery")
5 | local alert = require("hs.alert")
6 |
7 | local PreviousPowerSource = battery.powerSource()
8 |
9 | return battery.watcher.new(function()
10 | local total, count = 0, 0
11 | local CurrentPowerSource = battery.powerSource()
12 | if CurrentPowerSource ~= PreviousPowerSource then
13 | if CurrentPowerSource ~= "AC Power" then
14 | for volume in require("hs.fs").dir("/Volumes") do
15 | if not volume:match("^%.") and volume ~= "Yose" and volume ~= "DeepChaos" then
16 | local _,_,_,rc = hs.execute("diskutil umount '"..volume.."'")
17 | total = total + 1
18 | if tonumber(rc) == 0 then count = count + 1 end
19 | end
20 | end
21 | if total > 0 then
22 | alert.show("Auto dismount: "..tostring(count).." of "..tostring(total).." dismounted.")
23 | end
24 | end
25 | PreviousPowerSource = CurrentPowerSource
26 | end
27 | end) --:start()
28 |
--------------------------------------------------------------------------------
/utils/_actions/consoleHistory.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 | local console = require("hs.console")
3 | local settings = require("hs.settings")
4 | local timer = require("hs.timer")
5 |
6 | local hashFN = require("hs.hash").MD5 -- can use other hash fn if this proves insufficient
7 |
8 | local saveLabel = "_ASMConsoleHistory" -- label for saved history
9 | local checkInterval = settings.get(saveLabel.."_interval") or 1 -- how often to check for changes
10 | local maxLength = settings.get(saveLabel.."_max") or 100 -- maximum history to save
11 |
12 | local uniqueHistory = function(raw)
13 | local hashed, history = {}, {}
14 | for i = #raw, 1, -1 do
15 | local key = hashFN(raw[i])
16 | if not hashed[key] then
17 | table.insert(history, 1, raw[i])
18 | hashed[key] = true
19 | end
20 | end
21 | return history
22 | end
23 |
24 | module.clearHistory = function() return console.setHistory({}) end
25 |
26 | module.saveHistory = function()
27 | local hist, save = console.getHistory(), {}
28 | if #hist > maxLength then
29 | table.move(hist, #hist - maxLength, #hist, 1, save)
30 | else
31 | save = hist
32 | end
33 | -- save only the unique lines
34 | settings.set(saveLabel, uniqueHistory(save))
35 | end
36 |
37 | module.retrieveHistory = function()
38 | local history = settings.get(saveLabel)
39 | if (history) then
40 | console.setHistory(history)
41 | end
42 | end
43 |
44 | module.retrieveHistory()
45 | local currentHistoryCount = #console.getHistory()
46 |
47 | module.autosaveHistory = timer.new(checkInterval, function()
48 | local historyNow = console.getHistory()
49 | if #historyNow ~= currentHistoryCount then
50 | currentHistoryCount = #historyNow
51 | module.saveHistory()
52 | end
53 | end):start()
54 |
55 | module.pruneHistory = function()
56 | console.setHistory(uniqueHistory(console.getHistory()))
57 | currentHistoryCount = #console.getHistory()
58 | return currentHistoryCount
59 | end
60 |
61 | module = setmetatable(module, { __gc = function(_)
62 | _.saveHistory()
63 | end,
64 | })
65 |
66 | module.history = function(toFind)
67 | if type(toFind) == "number" then
68 | local history = console.getHistory()
69 | if toFind < 0 then toFind = #history - (toFind + 1) end
70 | local command = history[toFind]
71 | if command then
72 | print(">> " .. command)
73 | timer.doAfter(.1, function()
74 | local newHistory = console.getHistory()
75 | newHistory[#newHistory] = command
76 | console.setHistory(newHistory)
77 | end)
78 |
79 | local fn, err = load("return " .. command)
80 | if not fn then fn, err = load(command) end
81 | if fn then return fn() else return err end
82 |
83 | -- return load(command)()
84 | else
85 | error("nil item at specified history position", 2)
86 | end
87 | else
88 | toFind = toFind or ""
89 | for i,v in ipairs(console.getHistory()) do
90 | if v:match(toFind) then print(i, v) end
91 | end
92 | end
93 | end
94 |
95 | return module
96 |
--------------------------------------------------------------------------------
/utils/_actions/crash_test_dummy.lua:
--------------------------------------------------------------------------------
1 | local crash = require("hs.crash")
2 | local settings = require("hs.settings")
3 |
4 | crash.crashLogToNSLog = true ;
5 |
6 | if settings.get("_asm.crashIfNotMain") then
7 | local function crashifnotmain(reason)
8 | if not crash.isMainThread() then
9 | print("crashifnotmain called with reason", reason) -- may want to remove this, very verbose otherwise
10 | print("not in main thread, crashing")
11 | crash.crash()
12 | end
13 | end
14 | debug.sethook(crashifnotmain, 'c')
15 | return true
16 | else
17 | return false
18 | end
19 |
20 |
--------------------------------------------------------------------------------
/utils/_actions/dots.lua:
--------------------------------------------------------------------------------
1 | -- Based on Szymon Kaliski's code found at https://github.com/szymonkaliski/Dotfiles/blob/ae42c100a56c26bc65f6e3ca2ad36e30b558ba10/Dotfiles/hammerspoon/utils/spaces/dots.lua
2 |
3 |
4 | local spaces = require("hs.spaces")
5 | local screen = require("hs.screen")
6 | local _spaces = require("hs._asm.undocumented.spaces")
7 | local fnutils = require("hs.fnutils")
8 | local drawing = require("hs.drawing")
9 |
10 | local cache = {
11 | watchers = {},
12 | dots = {}
13 | }
14 |
15 | local module = {}
16 |
17 | module.size = 8
18 | module.distance = 16
19 | module.cache = cache
20 | module.color = { white = 0.7, alpha = 0.45 }
21 | module.selectedColor = { white = 0.7, alpha = 0.95 }
22 | module.activeColor = { green = 0.5, alpha = 0.75 }
23 |
24 | module.draw = function()
25 | local activeSpace = _spaces.activeSpace()
26 |
27 | for k, v in pairs(cache.dots) do
28 | cache.dots[k].stillHere = false
29 | end
30 | -- FIXME: what if I remove screen, the dots are still being drawn?
31 | fnutils.each(screen.allScreens(), function(screen)
32 | local screenFrame = screen:fullFrame()
33 | local screenUUID = screen:spacesUUID()
34 | local screenSpaces = _spaces.layout()[screenUUID]
35 |
36 | if screenSpaces then -- when screens don't have separate spaces, it won't appear in the layout
37 | if not cache.dots[screenUUID] then cache.dots[screenUUID] = {} end
38 | cache.dots[screenUUID].stillHere = true
39 |
40 | for i = 1, math.max(#screenSpaces, #cache.dots[screenUUID]) do
41 | local dot
42 |
43 | if not cache.dots[screenUUID][i] then
44 | dot = drawing.circle({ x = 0, y = 0, w = module.size, h = module.size })
45 |
46 | dot
47 | :setStroke(false)
48 | -- :setBehaviorByLabels({ 'canJoinAllSpaces', 'stationary' })
49 | :setBehaviorByLabels({ 'canJoinAllSpaces' })
50 | -- :setLevel(drawing.windowLevels.desktopIcon)
51 | :setLevel(drawing.windowLevels.popUpMenu)
52 | else
53 | dot = cache.dots[screenUUID][i]
54 | end
55 |
56 | local x = screenFrame.x + screenFrame.w / 2 - (#screenSpaces / 2) * module.distance + i * module.distance - module.size * 3 / 2
57 | local y = screenFrame.y + screenFrame.h - (module.distance/2)
58 | -- local y = module.distance
59 | -- local y = screenFrame.h - module.distance
60 |
61 | local dotColor = module.color
62 | if screenSpaces[i] == activeSpace then
63 | dotColor = module.activeColor
64 | else
65 | for i2, v2 in ipairs(_spaces.query(_spaces.masks.currentSpaces)) do
66 | if screenSpaces[i] == v2 then
67 | dotColor = module.selectedColor
68 | break
69 | end
70 | end
71 | end
72 |
73 | dot
74 | :setTopLeft({ x = x, y = y })
75 | :setFillColor(dotColor)
76 |
77 | if i <= #screenSpaces then
78 | dot:show()
79 | else
80 | dot:hide()
81 | end
82 |
83 | cache.dots[screenUUID][i] = dot
84 | end
85 | end
86 | end)
87 | for k, v in pairs(cache.dots) do
88 | if not cache.dots[k].stillHere then
89 | for i, v2 in ipairs(cache.dots[k]) do
90 | v2:delete()
91 | end
92 | cache.dots[k] = nil
93 | end
94 | end
95 | end
96 |
97 | module.start = function()
98 | -- we need to redraw dots on screen and space events
99 | cache.watchers.spaces = spaces.watcher.new(module.draw):start()
100 | cache.watchers.screen = screen.watcher.newWithActiveScreen(module.draw):start()
101 | module.draw()
102 | end
103 |
104 | module.stop = function()
105 | fnutils.each(cache.watchers, function(watcher) watcher:stop() end)
106 |
107 | cache.dots = {}
108 | end
109 |
110 | module.start()
111 |
112 | return module
--------------------------------------------------------------------------------
/utils/_actions/inspectors.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 | local timer = require("hs.timer")
3 |
4 | inspect = require("hs.inspect")
5 |
6 | timestamp = function(date)
7 | date = date or timer.secondsSinceEpoch()
8 | return os.date("%F %T" .. string.format("%-5s", ((tostring(date):match("(%.%d+)$")) or "")), math.floor(date))
9 | end
10 |
11 | local inspectWrapper = function(what, how, actual)
12 | how = how or {}
13 | for k, v in pairs(how) do actual[k] = v end
14 | return inspect(what, actual)
15 | end
16 | inspectm = function(what, how) return inspectWrapper(what, how, { metatables = 1 }) end
17 | inspect1 = function(what, how) return inspectWrapper(what, how, { depth = 1 }) end
18 | inspect2 = function(what, how) return inspectWrapper(what, how, { depth = 2 }) end
19 | inspecta = function(what, how) return inspectWrapper(what, how, {
20 | process = function(i,p) if p[#p] ~= "n" then return i end end
21 | }) end
22 |
23 | -- finspect = function(...)
24 | -- local args = table.pack(...)
25 | -- if args.n == 1 and type(args[1]) == "table" then
26 | -- args = args[1]
27 | -- else
28 | -- args.n = nil -- supress the count from table.pack
29 | -- end
30 | -- return (inspect(args):gsub("%s+", " "))
31 | -- end
32 |
33 | finspect = function(...)
34 | local args = table.pack(...)
35 | if args.n == 1 and type(args[1]) == "table" then
36 | args = args[1]
37 | else
38 | args.n = nil -- supress the count from table.pack
39 | end
40 |
41 | -- causes issues with recursive calls to __tostring in inspect
42 | local mt = getmetatable(args)
43 | if mt then setmetatable(args, nil) end
44 | local answer = inspect(args, { newline = " ", indent = "" })
45 | if mt then setmetatable(args, mt) end
46 | return answer
47 | end
48 |
49 | minspect = function(stuff)
50 | return (inspect(stuff, { process = function(item, path)
51 | if path[#path] == inspect.KEY then return item end
52 | if path[#path] == inspect.METATABLE then return nil end
53 | if #path > 0 and type(item) == "table" then
54 | return finspect(item)
55 | else
56 | return item
57 | end
58 | end
59 | }):gsub("[\"']{", "{"):gsub("}[\"']", "}"))
60 | end
61 |
62 | finspect2 = function(what, ...)
63 | local fn, opt = inspect, {}
64 | for i,v in ipairs(table.pack(...)) do
65 | -- "inspect" is a table with a __call metamethod, so...
66 | local vType = (getmetatable(v) or {}).__call and "function" or type(v)
67 | if vType == "function" then fn = v end
68 | if vType == "table" then opt = v end
69 | end
70 | return (fn(what, opt):gsub("%s+", " "))
71 | end
72 |
73 | module.help = function(...)
74 | local output = [[
75 |
76 | This module creates some shortcuts for inspecting Lua data:
77 |
78 | inspect - equivalent to `hs.inspect`
79 |
80 | inspectm - include options { metatables = 1} by default
81 | inspect1 - include options { depth = 1 } by default
82 | inspect2 - include options { depth = 2 } by default
83 | inspecta - includes process function in options table to remove `n` key from tables;
84 | this allows tables which contain non-numeric keys only because of
85 | table.pack to be treated as the arrays they really are.
86 |
87 | finspect(...) - inspects the arguments, first combining them into a table if more
88 | then one or if the one provided is not already a table. Flattens
89 | the output by replacing run-on spaces, tabs, and newlines into a
90 | single space.
91 |
92 | finspect2(what, [fn], [opt]) - inspects `what` with the function `fn` (default is
93 | "inspect") with the specfied options (default {}) and
94 | "flattens" the output by replacing run-on spaces, tabs,
95 | and newlines into a single space.
96 |
97 | timestamp([number]) - returns the current or specified time as a string in the format
98 | of 'YYYY-MM-DD hh:mm:ss.nnnn'
99 |
100 | Note that a second argument to any of the `inspect*` shortcuts is appended to the
101 | default table described; i.e. if you specify the same key in your options table,
102 | your value will override the default.
103 |
104 | ]]
105 | return output
106 | end
107 |
108 | module = setmetatable(module, {
109 | __tostring = function(self) return self.help() end,
110 | __call = function(self, ...) return self.help(...) end,
111 | })
112 |
113 | return module
114 |
--------------------------------------------------------------------------------
/utils/_actions/localAssets.lua:
--------------------------------------------------------------------------------
1 | --
2 | -- local assets web server -- I don't want to have to rely on internet access all of the
3 | -- time, so a local web server takes care of those things that I might need...
4 |
5 | local module = {}
6 |
7 | local hsminweb = require("hs.httpserver.hsminweb")
8 | local serverPort = 7734
9 | local documentRoot = hs.configdir.."/_localAssets"
10 |
11 | module.server = hsminweb.new(documentRoot):port(serverPort)
12 | :allowDirectory(true)
13 | :name("localAssets")
14 | :bonjour(false)
15 | :cgiEnabled(true)
16 | :luaTemplateExtension("lp")
17 | :directoryIndex{
18 | "index.html", "index.lp", "index.cgi",
19 | }:accessList{
20 | {"X-Remote-Addr", "::1", false, true},
21 | {"X-Remote-Addr", "127.0.0.1", false, true},
22 | -- technically optional, but I like being explicit
23 | {"*", "*", false, false},
24 | }
25 | :start()
26 |
27 | module.server._logBadTranslations = true
28 | module.server._logPageErrorTranslations = true
29 | module.server._allowRenderTranslations = true
30 |
31 | module.hsdocs = require"hs.doc.hsdocs".start()
32 |
33 | return module
34 |
--------------------------------------------------------------------------------
/utils/_actions/loopcatcher.lua:
--------------------------------------------------------------------------------
1 | --
2 | -- uses debug.sethook and a timer to break out of infinite loops in lua code within Hammerspoon
3 | --
4 | -- Haven't had any problems with it or false positives, but YMMV -- standard disclaimers, etc.
5 | --
6 | -- Updates 2015-12-21:
7 | -- should play nicely with other hooks by storing info about it and chaining
8 | -- you can force an "immediate" break by holding down CMD-CTRL-SHIFT-ALT-CAPSLOCK-FN all at once
9 | -- you'll need to remove "and mods.fn" where noted below if your keyboard does not have this
10 | -- modifier (non-laptops, I suspect)
11 | --
12 | -- See https://gist.github.com/asmagill/cf1d6398aecc2cee37af for additional release notes
13 | --
14 | -- You can disable this (and all debug hooks) at any time by typing `debug.sethook(nil)` into the
15 | -- Hammerspoon Console.
16 |
17 | local module = {}
18 |
19 | local timer = require("hs.timer")
20 | -- local caffeinate = require("hs.caffeinate")
21 | local eventtap = require("hs.eventtap")
22 |
23 | -- -- testing infinite loop detector with debug.sethook
24 |
25 | local lastFn, lastMask, lastCount = debug.gethook()
26 |
27 | local setHook = function(ourFn, ourMask, ourCount)
28 | if ourFn then
29 | lastFn, lastMask, lastCount = debug.gethook()
30 | if lastCount > 0 and lastCount < ourCount then ourCount = lastCount end
31 | for i = 1, #lastMask, 1 do
32 | if not ourMask:match(lastMask:sub(i,i)) then
33 | ourMask = ourMask..lastMask:sub(i,i)
34 | end
35 | end
36 | -- print("*** setting Hook:", ourFn, ourMask.."("..#ourMask..")", ourCount)
37 | debug.sethook(ourFn, ourMask, ourCount)
38 | else
39 | debug.sethook(lastFn, lastMask, lastCount)
40 | end
41 | end
42 |
43 | -- module._loopTimeStamp = os.time()
44 | -- module._loopTimer = timer.new(5, function() module._loopTimeStamp = os.time() end):start()
45 | module._loopChecker = function(t,l)
46 | if lastFn then lastFn(t, l) end
47 | -- if (os.time() - module._loopTimeStamp) > 60 then
48 | -- module._loopTimeStamp = os.time()
49 | -- error("*** timeout -- infinite loop somewhere?\n\n"..debug.traceback(), 0)
50 | -- end
51 | local mods = eventtap.checkKeyboardModifiers()
52 | -- remove "and mods.fn" if your keyboard does not have this key (non laptops most likely)
53 | if mods.capslock and mods.fn and mods.cmd and mods.ctrl and mods.alt and mods.shift then
54 | error("*** forced break\n\n"..debug.traceback(), 0)
55 | end
56 | end
57 |
58 | -- module._loopSleepWatcher = caffeinate.watcher.new(function(event)
59 | -- if event == caffeinate.watcher.systemDidWake then
60 | -- module._loopTimeStamp = os.time()
61 | -- setHook(module._loopChecker, "", 1000)
62 | -- elseif event == caffeinate.watcher.systemWillSleep then
63 | -- setHook(nil)
64 | -- end
65 | -- end):start()
66 |
67 | setHook(module._loopChecker, "", 100)
68 |
69 | return module
70 |
--------------------------------------------------------------------------------
/utils/_actions/luaFileChangeWatcher.lua:
--------------------------------------------------------------------------------
1 | local pathwatcher = require"hs.pathwatcher"
2 | local inspect = require"hs.inspect"
3 |
4 | local module = {}
5 |
6 | module.watcher = pathwatcher.new(hs.configdir, function(changedFiles, changedFlags)
7 | local luaFileFound = false
8 | for i = 1, #changedFiles, 1 do
9 | if changedFiles[i]:match("%.lua$") then
10 | hs.printf("\t%s — %s", (changedFiles[i]:gsub("^" .. hs.configdir, "…")), (inspect(changedFlags[i]):gsub(" = true", ""):gsub("%s+", " ")))
11 | luaFileFound = true
12 | end
13 | end
14 | if luaFileFound then
15 | print("\tyou might want to reload!")
16 | end
17 | end):start ()
18 |
19 | return module
20 |
--------------------------------------------------------------------------------
/utils/_actions/nc.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 | require("utils._actions.inspectors")
3 |
4 | local ignoreInWorkspaceObserver = {
5 | NSWorkspaceActiveSpaceDidChangeNotification = true,
6 | NSWorkspaceDidActivateApplicationNotification = true,
7 | NSWorkspaceDidDeactivateApplicationNotification = true,
8 | NSWorkspaceDidHideApplicationNotification = true,
9 | NSWorkspaceDidLaunchApplicationNotification = true,
10 | NSWorkspaceDidMountNotification = true,
11 | NSWorkspaceDidRenameVolumeNotification = true,
12 | NSWorkspaceDidTerminateApplicationNotification = true,
13 | NSWorkspaceDidUnhideApplicationNotification = true,
14 | NSWorkspaceDidUnmountNotification = true,
15 | NSWorkspaceDidWakeNotification = true,
16 | NSWorkspaceScreensDidSleepNotification = true,
17 | NSWorkspaceScreensDidWakeNotification = true,
18 | NSWorkspaceSessionDidBecomeActiveNotification = true,
19 | NSWorkspaceSessionDidResignActiveNotification = true,
20 | NSWorkspaceWillLaunchApplicationNotification = true,
21 | NSWorkspaceWillPowerOffNotification = true,
22 | NSWorkspaceWillSleepNotification = true,
23 | NSWorkspaceWillUnmountNotification = true,
24 | NSWorkspaceActiveDisplayDidChangeNotification = true,
25 | }
26 |
27 | local nc = require "hs._asm.notificationcenter"
28 | local distributednotifications = require "hs.distributednotifications"
29 | local fnutils = require "hs.fnutils"
30 |
31 | module.workspaceObserver = nc.workspaceObserver(function(n,o,i)
32 | if not ignoreInWorkspaceObserver[n] then
33 | local f = io.open("__workspaceobserver.txt","a") ;
34 | f:write(os.date().."\t".."name:"..inspect(n).."\tobj:"..inspect(o):gsub("%s+"," ").."\tinfo:"..inspect(i):gsub("%s+"," ").."\n")
35 | f:close()
36 | end
37 | end):start()
38 |
39 | local do_logFile = "__distributedobserver_core.log"
40 |
41 | local f, err = io.open(do_logFile, "r")
42 | if f then
43 | local logData = f:read("a")
44 | f:close()
45 | local asArray = fnutils.split(logData, "[\r\n]")
46 | if #asArray > 1000 then
47 | local newArray = {}
48 | table.move(asArray, #asArray - 1000, #asArray, 1, newArray)
49 | f, err = io.open(do_logFile, "w")
50 | if f then
51 | f:write(table.concat(newArray, "\n"))
52 | f:close()
53 | else
54 | print("unable to create truncated " .. do_logFile .. " (" .. err ..")")
55 | end
56 | end
57 | else
58 | print("unable to read " .. do_logFile .. " to check length (" .. err ..")")
59 | end
60 |
61 | module.distributedObserver_core = distributednotifications.new(function(n,o,i)
62 | local f = io.open(do_logFile,"a") ;
63 | f:write(timestamp().."\t".."name:"..inspect(n).."\tobj:"..inspect(o):gsub("%s+"," ").."\tinfo:"..inspect(i):gsub("%s+"," ").."\n")
64 | f:close()
65 | end):start() -- gets big fast, so let me turn it on when I want to explore
66 |
67 | return module
68 |
--------------------------------------------------------------------------------
/utils/_actions/popConsole.lua:
--------------------------------------------------------------------------------
1 | local noises = require("hs.noises")
2 | local watchable = require("hs.watchable")
3 | local window = require("hs.window")
4 | local application = require("hs.application")
5 | local timer = require("hs.timer")
6 |
7 | local module = {}
8 | module.watchables = watchable.new("popConsole", true)
9 | module.watchables.enabled = true
10 |
11 | module.popTimeout = 1
12 | module.debug = false
13 |
14 | local prevWindowHolder
15 |
16 | local popTimer
17 | local popCount = 0
18 |
19 | local consoleToggleThingy = function()
20 | -- this attempts to keep track of the previously focused window and return us to it
21 | local conswin = window.get("Hammerspoon Console")
22 | if conswin and application.get("Hammerspoon"):isFrontmost() then
23 | conswin:close()
24 | if prevWindowHolder and #prevWindowHolder:role() ~= 0 then
25 | prevWindowHolder:becomeMain():focus()
26 | prevWindowHolder = nil
27 | end
28 | else
29 | prevWindowHolder = window.frontmostWindow()
30 | hs.openConsole()
31 | end
32 | end
33 |
34 | local handlePops = function()
35 | if module.debug then hs.printf("~~ heard %d pop(s) in %d second(s)", popCount, module.popTimeout) end
36 | if popCount == 2 then
37 | consoleToggleThingy()
38 | end
39 | popTimer = nil
40 | popCount = 0
41 | end
42 |
43 | local consolePopWatcher = function()
44 | if not popTimer then
45 | popTimer = timer.doAfter(module.popTimeout, handlePops)
46 | end
47 | popCount = popCount + 1
48 | end
49 |
50 | module.callback = function(w)
51 | if w == 1 then -- start "sssss" sound
52 | elseif w == 2 then -- end "sssss" sound
53 | elseif w == 3 then -- mouth popping sound
54 | consolePopWatcher()
55 | end
56 | end
57 |
58 | module._noiseWatcher = noises.new(module.callback):start()
59 |
60 | module.toggleForWatchablesEnabled = watchable.watch("popConsole.enabled", function(w, p, i, oldValue, value)
61 | if value then
62 | module._noiseWatcher:start()
63 | else
64 | module._noiseWatcher:stop()
65 | end
66 | end)
67 |
68 | local caffeinate = require("hs.caffeinate")
69 | -- the listener can prevent or delay system sleep, so disable as appropriate
70 | module.watchCaffeinatedState = watchable.watch("generalStatus.caffeinatedState", function(w, p, i, old, new)
71 | -- print(string.format("~~~ %s popConsole caffeinatedWatcher called with %s (%d), was %s (%d), currently %s", timestamp(), caffeinate.watcher[new], new, caffeinate.watcher[old], old, module.watchables.enabled))
72 | if new == 1 or new == 10 then -- systemWillSleep or screensDidLock
73 | module.wasActive = module.watchables.enabled
74 | module.watchables.enabled = false
75 | elseif new == 0 or new == 11 then -- systemDidWake or screensDidUnlock
76 | if type(module.wasActive) == "boolean" then
77 | module.watchables.enabled = module.wasActive
78 | else
79 | module.watchables.enabled = true
80 | end
81 | end
82 | end)
83 |
84 | return setmetatable(module, { __tostring = function(self)
85 | return "Adjust with `self`.watchables.enabled or using hs.watchables with path 'popConsole.enabled'"
86 | end })
87 |
--------------------------------------------------------------------------------
/utils/_actions/preParsers.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 | local ipc = require("hs.ipc")
3 |
4 | -- pre-parser core
5 | local preParser = function(s)
6 | -- allow !# like bash to redo a command from the history
7 | local historyNumber = s:match("^!(-?%d+)$")
8 | if historyNumber then s = "history(" .. historyNumber .. ")" end
9 |
10 | -- allow `history what`
11 | if s:match("^history%s+[^\"]") then s = s:gsub("^history ", "history \"") .. "\"" end
12 |
13 | if s:match("^help") and not s:match("^help%.") then
14 | -- allow help(what) without quotes
15 | local helpParen = s:match("^help%s*%(([^\"]*)%)%s*$")
16 | if helpParen then
17 | if helpParen == "" then
18 | s = "help"
19 | else
20 | s = "help." .. helpParen
21 | end
22 | end
23 |
24 | -- allow `help what`
25 | if s:match("^help%s+[^\"]") then s = s:gsub("^help%s+", "help.") end
26 | end
27 | return s
28 | end
29 |
30 | -- pre-parser for Console
31 | local previousParser = hs._consoleInputPreparser
32 | hs._consoleInputPreparser = function(s)
33 | if previousParser then s = previousParser(s) end
34 | -- invoke my common pre-parser
35 | return preParser(s)
36 | end
37 |
38 | -- pre-parser for ipc's command line tool
39 | -- local ipcRawhandler = ipc.handler
40 | -- ipc.handler = function(str)
41 | -- str = preParser(str)
42 | -- return ipcRawhandler(str)
43 | -- end
44 |
45 | module.help = function(...)
46 | local output = [[
47 |
48 | This module preparses input from the Console or from the IPC `hs` command line tool. The
49 | following conversions are applied:
50 |
51 | !# - performs the command at the specified number in the console history;
52 | negative numbers are offset from the history end
53 | history what - automatically wraps `what` in quotes, if it isn't already
54 | help(what) - automatically wraps `what` in quotes, if it isn't already
55 | help what - replaces the first space with a period to take advantage of help's
56 | __tostring methods
57 |
58 | ]]
59 | return output
60 | end
61 |
62 | module = setmetatable(module, {
63 | __tostring = function(self) return self.help() end,
64 | __call = function(self, ...) return self.help(...) end,
65 | })
66 |
67 | return module
68 |
--------------------------------------------------------------------------------
/utils/_actions/remoteCheck.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 |
3 | local task = require("hs.task")
4 | local stext = require("hs.styledtext")
5 | local timer = require("hs.timer")
6 | local settings = require("hs.settings")
7 | local watchable = require"hs.watchable"
8 |
9 | local hosts = {
10 | "tesla.private",
11 | "marconi.private",
12 | "hedylamarr.private",
13 | }
14 |
15 | local style = {
16 | font = { name = "Menlo", size = 10 },
17 | color = { alpha = 1.0 },
18 | paragraphStyle = { lineBreak = "clip" },
19 | }
20 |
21 | local myTasks = {}
22 | local myOutput = {}
23 |
24 | module.updateTasks = function()
25 | for i, v in ipairs(hosts) do
26 | if myTasks[v] and myTasks[v]:isRunning() then
27 | -- print("-- "..v.." still running")
28 | else
29 | if module.vpnStatus and module.vpnStatus:value() then
30 | myOutput[v] = stext.new(v.." is polling...\n", style):setStyle{
31 | color = { list = "Crayons", name = "Sea Foam" },
32 | font = stext.convertFont(style.font, stext.fontTraits.italicFont),
33 | }
34 | myTasks[v] = task.new("/sbin/ping", function(c, o, e)
35 | local output = o:gsub("^PING.+[\r\n][\r\n]", "")
36 | local soutput = stext.new(output, style)
37 | if c == 2 then
38 | soutput = soutput:setStyle{
39 | color = { red = 1.0 },
40 | paragraphStyle = { lineBreak = "wordWrap" },
41 | }
42 | else
43 | local _, e1 = output:find("^[^\r\n]+[\r\n]")
44 | local s2, e2, loss = output:find("(%d+%.%d+)%% packet loss")
45 | loss = tonumber(loss)
46 | local pStyle = (loss < 5.0) and { color = { list = "Apple", name = "Green" } } or
47 | ((loss < 10.0) and { color = { list = "Apple", name = "Yellow" } } or
48 | { color = { list = "Apple", name = "Red" } })
49 | soutput = soutput:setStyle({
50 | color = { list = "x11", name = "mediumvioletred" },
51 | font = stext.convertFont(style.font, stext.fontTraits.italicFont),
52 | }, 5, e1 - 5):setStyle(pStyle, s2, e2)
53 | end
54 | myOutput[v] = soutput
55 | _asm._actions.geeklets.geeklets.remoteCheck.lastRun = os.time() - _asm._actions.geeklets.geeklets.remoteCheck.period
56 | myOutput[v] = myOutput[v]..stext.new("Last Check: "..os.date(), style):setStyle{
57 | color = { list = "x11", name = "royalblue" },
58 | font = stext.convertFont(style.font, stext.fontTraits.italicFont),
59 | paragraphStyle = {
60 | alignment = "right"
61 | },
62 | }
63 | end, { "-c10", "-q", v }):start()
64 | else
65 | myOutput[v] = stext.new(v..": VPN is Down\n", style):setStyle{
66 | color = { list = "Crayons", name = "Sea Foam" },
67 | font = stext.convertFont(style.font, stext.fontTraits.italicFont),
68 | }
69 | _asm._actions.geeklets.geeklets.remoteCheck.lastRun = os.time() - _asm._actions.geeklets.geeklets.remoteCheck.period
70 | end
71 | end
72 | end
73 | end
74 |
75 | module.vpnStatus = watchable.watch("generalStatus.privateVPN", module.updateTasks)
76 |
77 | module.output = myOutput
78 | module.tasks = myTasks
79 | module.timer = timer.new(300, module.updateTasks):start()
80 |
81 | -- ensure this is triggered after we load, so _asm._actions exists
82 | timer.doAfter(1, module.updateTasks)
83 |
84 | return module
85 |
--------------------------------------------------------------------------------
/utils/_actions/screen_bluetooth_toggle.lua:
--------------------------------------------------------------------------------
1 | -- For my setup, when the number of monitors == 1, it's likely that I'm either
2 | -- using the battery and not my external mouse, or that I'm using the computer
3 | -- just far enough from my desk (watching TV, most likely) that the mouse is
4 | -- barely in range and drains it's battery trying to stay connected... so...
5 | -- we turn it off when I drop to one monitor. I can always toggle it back (see
6 | -- _keys).
7 |
8 | local screen = require("hs.screen")
9 | local alert = require("hs.alert")
10 |
11 | local prevScreens = #screen.allScreens()
12 |
13 | return screen.watcher.new(function()
14 | local numScreens = #screen.allScreens()
15 | if numScreens ~= prevScreens then
16 | local btooth = require("hs._asm.undocumented.bluetooth")
17 | if numScreens == 1 then
18 | if btooth.available() and btooth.power() then
19 | alert.show("Turning bluetooth off to conserve mouse battery.",5)
20 | btooth.power(false)
21 | end
22 | else
23 | if btooth.available() and not btooth.power() then
24 | alert.show("Turning bluetooth on.",5)
25 | btooth.power(true)
26 | end
27 | end
28 | prevScreens = numScreens
29 | end
30 | end) -- :start()
31 |
--------------------------------------------------------------------------------
/utils/_keys/documentsWebServer.lua:
--------------------------------------------------------------------------------
1 | --
2 | -- Toggle private webserver for documentation... smaller footprint than Apache, but even so, not needed often
3 |
4 | local module = {}
5 |
6 | local hsminweb = require("hs.httpserver.hsminweb")
7 | local hotkey = require("hs.hotkey")
8 | local alert = require("hs.alert").show
9 |
10 | local serverPort = 8192
11 | local documentRoot = os.getenv("HOME") .. "/Sites"
12 |
13 | module.server = hsminweb.new(documentRoot):port(serverPort)
14 | :allowDirectory(true)
15 | :name("Sites")
16 | :bonjour(true)
17 | :cgiEnabled(true)
18 | :luaTemplateExtension("lp")
19 | :directoryIndex{
20 | "index.html", "index.lp", "index.cgi",
21 | }:accessList{
22 | {"X-Remote-Addr", "::1", false, true},
23 | {"X-Remote-Addr", "127.0.0.1", false, true},
24 | {"X-Remote-Addr", "^10%.0%.1%.", true, true},
25 | {"X-Remote-Addr", "^10%.161%.82%.", true, true},
26 | {"*", "*", false, false},
27 | }
28 |
29 | module.server._logBadTranslations = true
30 | module.server._logPageErrorTranslations = true
31 | module.server._allowRenderTranslations = true
32 | module.debugging = function(value)
33 | if type(value) == "boolean" then
34 | module.server._logBadTranslations = value
35 | module.server._logPageErrorTranslations = value
36 | module.server._allowRenderTranslations = value
37 | end
38 | print("** translation debugging:", module.server._logBadTranslations and "enabled" or "disabled")
39 | end
40 |
41 | module.hotkey = hotkey.bind({"cmd", "alt"}, "f10", function()
42 | if module.server._server then
43 | alert("Turning Documentation Server Off...")
44 | module.server:stop()
45 | else
46 | alert("Turning Documentation Server On (Port 8192)...")
47 | module.server:start()
48 | end
49 | end)
50 |
51 | return module
52 |
--------------------------------------------------------------------------------
/utils/_keys/information.lua:
--------------------------------------------------------------------------------
1 | local module = {
2 | --[=[
3 | _NAME = 'hydra.lua',
4 | _VERSION = '0.1',
5 | _URL = 'https://github.com/asmagill/hammerspoon-config',
6 | _DESCRIPTION = [[ personal keybindings for hammerspoon ]],
7 | _TODO = [[]],
8 | _LICENSE = [[ See README.md ]]
9 | --]=]
10 | }
11 |
12 | -- private variables and methods -----------------------------------------
13 |
14 | local mouse = require("hs.mouse")
15 | local pasteboard = require("hs.pasteboard")
16 | local devinfo = require("utils.dev_info")
17 | local mods = require("hs._asm.extras").mods
18 | local hotkey = require("hs.hotkey")
19 | local fnutils = require("hs.fnutils")
20 | local alert = require("hs.alert")
21 | local window = require("hs.window")
22 | local application = require("hs.application")
23 |
24 | local point_in_rect = function(rect, point)
25 | return point.x >= rect.x and
26 | point.y >= rect.y and
27 | point.x <= rect.x + rect.w and
28 | point.y <= rect.y + rect.h
29 | end
30 |
31 | local window_underneath_mouse = function()
32 | local pos = mouse.getAbsolutePosition()
33 | local win = fnutils.find(window.orderedWindows(), function(window)
34 | return point_in_rect(window:frame(), pos) and window:isStandard()
35 | end)
36 | return win or window.windowForID(0) or window.windowForID(nil)
37 | end
38 |
39 | local dev = hotkey.modal.new(mods.CAsC, "=")
40 | dev:bind(mods.Casc, "C",
41 | function()
42 | dev.clipboard = not dev.clipboard
43 | print("-- Clipping ----------------------------")
44 | print("Save to Clipboard = "..tostring(dev.clipboard))
45 | print("----------------------------------------")
46 | end
47 | )
48 | dev:bind(mods.casc, "W",
49 | function()
50 | local win = window_underneath_mouse()
51 | print("-- Window ------------------------------")
52 | print(devinfo.wininfo(win,dev.clipboard))
53 | print("----------------------------------------")
54 | end
55 | )
56 | dev:bind(mods.casc, "A",
57 | function()
58 | -- local win = window_underneath_mouse()
59 | local app = application.frontmostApplication()
60 | print("-- Application -------------------------")
61 | -- print(devinfo.appinfo(win:application(),dev.clipboard))
62 | print(devinfo.appinfo(app, dev.clipboard))
63 | print("----------------------------------------")
64 | end
65 | )
66 | dev:bind(mods.casc, "M",
67 | function()
68 | local win = window_underneath_mouse()
69 | print("-- Monitor -----------------------------")
70 | print(devinfo.screeninfo(win:screen(),dev.clipboard))
71 | print("----------------------------------------")
72 | end
73 | )
74 | -- dev:bind(mods.casc, "S",
75 | -- function()
76 | -- print(devinfo.spaceinfo(dev.clipboard))
77 | -- end
78 | -- )
79 | dev:bind(mods.casc, "B",
80 | function()
81 | print("-- Battery -----------------------------")
82 | print(devinfo.batteryinfo(dev.clipboard))
83 | print("----------------------------------------")
84 | end
85 | )
86 | dev:bind(mods.casc, "I",
87 | function()
88 | local results = devinfo.audioinfo(false).."\r"
89 | ..devinfo.mouseinfo(false).."\r"
90 | ..devinfo.brightnessinfo(false)
91 | print("-- Info --------------------------------")
92 | print(results)
93 | print("----------------------------------------")
94 | if dev.clipboard then
95 | pasteboard.setcontents(results)
96 | end
97 | end
98 | )
99 | dev:bind(mods.Casc, "V",
100 | function()
101 | print("-- Clipboard Contents ------------------")
102 | print(pasteboard.getContents())
103 | print("----------------------------------------")
104 | end
105 | )
106 |
107 | function dev:entered()
108 | alert.show("Entering Information Mode")
109 | dev.clipboard = false
110 | end
111 | function dev:exited()
112 | alert.show("Leaving Information Mode")
113 | dev.clipboard = false
114 | end
115 | dev:bind(mods.casc, "ESCAPE", function() dev:exit() end)
116 |
117 | -- Public interface ------------------------------------------------------
118 | -- Return Module Object --------------------------------------------------
119 |
120 | return module
121 |
--------------------------------------------------------------------------------
/utils/_keys/redshift.lua:
--------------------------------------------------------------------------------
1 | --local redshift = require("hs.redshift")
2 | local hotkey = require("hs.hotkey")
3 | local mods = require("hs._asm.extras").mods
4 | local alert = require("hs.alert")
5 | --local settings = require("hs.settings")
6 | local screen = require("hs.screen")
7 |
8 | local module = {
9 | help = "⌘-F11 and ⌘⌥-F11"
10 | }
11 |
12 | -- settings.clear("hs.redshift.inverted.override")
13 | -- settings.clear("hs.redshift.disabled.override")
14 |
15 | --redshift.start(2800,'21:00','7:00','4h')
16 |
17 | hotkey.bind(mods.Casc, "F11", function()
18 | alert("Toggle Invert")
19 | for i,v in ipairs(screen.allScreens()) do
20 | local gamma = v:getGamma()
21 | if gamma then
22 | v:setGamma(gamma.blackpoint, gamma.whitepoint)
23 | else
24 | print("~~ could not get gamma for " .. tostring(v:name()))
25 | end
26 | end
27 | -- redshift.toggleInvert()
28 | end)
29 |
30 | --hotkey.bind(mods.CAsc, "F11", function()
31 | -- alert("Toggle Redshift")
32 | -- redshift.toggle()
33 | --end)
34 | --
35 | --local watchable = require("hs.watchable")
36 | --module.watchCaffeinatedState = watchable.watch("generalStatus.caffeinatedState", function(w, p, i, old, new)
37 | -- if new == 0 or new == 9 then -- systemDidWake or screensaverDidStop
38 | -- redshift.start(2800,'21:00','7:00','4h')
39 | -- elseif new == 1 or new == 7 then -- systemWillSleep or screensaverDidStart
40 | -- redshift.stop()
41 | -- end
42 | --end)
43 |
44 | return module
45 |
--------------------------------------------------------------------------------
/utils/_keys/switcher.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 |
3 | local switcher = require"hs.window.switcher"
4 | local filter = require"hs.window.filter"
5 | local hotkey = require"hs.hotkey"
6 | local mods = require"hs._asm.extras".mods
7 |
8 | module.switcher = switcher.new(filter.new():setDefaultFilter{}, {
9 | selectedThumbnailSize = 288,
10 | thumbnailSize = 96,
11 | showTitles = false,
12 | -- showSelectedThumbnail = false, -- wish it would just show the selected title, but this gets rid of both
13 | textSize = 7,
14 |
15 | textColor = { 1.0, 1.0, 1.0, 0.75 },
16 | backgroundColor = { 0.3, 0.3, 0.3, 0.75 },
17 | highlightColor = { 0.8, 0.5, 0.0, 0.80 },
18 | titleBackgroundColor = { 0.0, 0.0, 0.0, 0.75 },
19 | })
20 |
21 | -- bind to hotkeys; WARNING: at least one modifier key is required!
22 | hotkey.bind(mods.cAsc, 'tab', function() module.switcher:next() end)
23 | hotkey.bind(mods.cASc, 'tab', function() module.switcher:previous() end)
24 |
25 | return module
--------------------------------------------------------------------------------
/utils/_keys/viKeys.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 |
3 | module.debugging = false -- whether to print status updates
4 |
5 | local eventtap = require "hs.eventtap"
6 | local event = eventtap.event
7 | local inspect = require "hs.inspect"
8 | local watchable = require "hs.watchable"
9 |
10 |
11 | local keyHandler = function(e)
12 | local watchFor = { h = "left", j = "down", k = "up", l = "right" }
13 | local actualKey = e:getCharacters(true)
14 | local replacement = watchFor[actualKey:lower()]
15 | if replacement then
16 | local isDown = e:getType() == event.types.keyDown
17 | local flags = {}
18 | for k, v in pairs(e:getFlags()) do
19 | if v and k ~= "fn" then -- fn will be down because that's our "wrapper", so ignore it
20 | table.insert(flags, k)
21 | end
22 | end
23 | if module.debugging then print("viKeys: " .. replacement, inspect(flags), isDown) end
24 | local replacementEvent = event.newKeyEvent(flags, replacement, isDown)
25 | if isDown then
26 | -- allow for auto-repeat
27 | replacementEvent:setProperty(event.properties.keyboardEventAutorepeat, e:getProperty(event.properties.keyboardEventAutorepeat))
28 | end
29 | return true, { replacementEvent }
30 | else
31 | return false -- do nothing to the event, just pass it along
32 | end
33 | end
34 |
35 | local modifierHandler = function(e)
36 | local flags = e:getFlags()
37 | local onlyFNPressed = false
38 | for k, v in pairs(flags) do
39 | onlyFNPressed = v and k == "fn"
40 | if not onlyFNPressed then break end
41 | end
42 | -- you must tap and hold fn by itself to turn this on
43 | if onlyFNPressed and not module.keyListener then
44 | if module.debugging then print("viKeys: keyhandler on") end
45 | module.keyListener = eventtap.new({ event.types.keyDown, event.types.keyUp }, keyHandler):start()
46 | -- however, adding additional modifiers afterwards is ok... its only when fn isn't down that we switch back off
47 | elseif not flags.fn and module.keyListener then
48 | if module.debugging then print("viKeys: keyhandler off") end
49 | module.keyListener:stop()
50 | module.keyListener = nil
51 | end
52 | return false
53 | end
54 |
55 | module.watchables = watchable.new("viKeys", true)
56 |
57 | module.modifierListener = eventtap.new({ event.types.flagsChanged }, modifierHandler)
58 |
59 | module.start = function()
60 | module.watchables.enabled = true
61 | module.modifierListener:start()
62 | end
63 |
64 | module.stop = function()
65 | if module.keyListener then
66 | module.keyListener:stop()
67 | module.keyListener = nil
68 | end
69 | module.modifierListener:stop()
70 | module.watchables.enabled = false
71 | end
72 |
73 | module.toggle = function()
74 | if module.watchable.enabled then
75 | module.stop()
76 | else
77 | module.start()
78 | end
79 | end
80 |
81 | module.watchExternalToggle = watchable.watch("viKeys.enabled", function(w, p, k, o, n)
82 | if not o and n then
83 | module.start()
84 | elseif o and not n then
85 | module.stop()
86 | end
87 | end)
88 |
89 | module.start() -- autostart
90 |
91 | return module
92 |
--------------------------------------------------------------------------------
/utils/_keys/windowMemory.lua:
--------------------------------------------------------------------------------
1 | local mods = require("hs._asm.extras").mods
2 | local hotkey = require("hs.hotkey")
3 | local fnutils = require("hs.fnutils")
4 | local mouse = require("hs.mouse")
5 | local geometry = require("hs.geometry")
6 | local window = require("hs.window")
7 | local alert = require("hs.alert")
8 |
9 | local alertStyle = { fillColor = { blue = .6, green = .5 } }
10 |
11 | local pickWindow = function()
12 | return window.frontmostWindow()
13 | -- return fnutils.find(window.orderedWindows(), function(_)
14 | -- return geometry.isPointInRect(mouse.getAbsolutePosition(), _:frame()) and _:isStandard()
15 | -- end)
16 | end
17 |
18 | local _firstTime = true
19 |
20 | local module = {}
21 | module._savedWindows = {}
22 |
23 | local saveWindow = function(key)
24 | local win = pickWindow()
25 | if win then
26 | module._savedWindows[key] = win
27 | local app = win:application():name() or ""
28 | local win = win:title() or ""
29 | alert(app .. ":" .. win .. " saved to slot " .. tostring(key), alertStyle)
30 | else
31 | alert("Unable to get window object", alertStyle)
32 | end
33 | end
34 |
35 | local gotoWindow = function(key)
36 | local win = module._savedWindows[key]
37 | if win then
38 | if win:role() ~= "" then
39 | win:focus()
40 | else
41 | module._savedWindows[key] = nil
42 | alert("Window in slot " .. tostring(key) .. " is no longer valid", alertStyle)
43 | end
44 | else
45 | alert("No window saved in slot " .. tostring(key), alertStyle)
46 | end
47 | end
48 |
49 | module._keys = hotkey.modal.new()
50 | module._keys.entered = function(self)
51 | if not _firstTime then
52 | alert("Window slot saver enable", alertStyle)
53 | _firstTime = false
54 | end
55 | end
56 | for i = 0, 9, 1 do
57 | module._keys:bind(mods.CASC, tostring(i), function() saveWindow(i) end)
58 | module._keys:bind(mods.CAsC, tostring(i), function() gotoWindow(i) end)
59 | end
60 | module._keys.exited = function(self)
61 | alert("Window slot saver disabled", alertStyle)
62 | end
63 |
64 | module.start = function() module._keys:enter() end
65 | module.stop = function() module._keys:exit() end
66 |
67 | module.start()
68 |
69 | return module
70 |
--------------------------------------------------------------------------------
/utils/_menus/XProtectStatus/XProtectPluginChecker.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asmagill/hammerspoon-config/432c65705203d7743d3298441bd4319137b466fd/utils/_menus/XProtectStatus/XProtectPluginChecker.png
--------------------------------------------------------------------------------
/utils/_menus/XProtectStatus/myXProtectStatus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asmagill/hammerspoon-config/432c65705203d7743d3298441bd4319137b466fd/utils/_menus/XProtectStatus/myXProtectStatus.png
--------------------------------------------------------------------------------
/utils/_menus/amphetamine.lua:
--------------------------------------------------------------------------------
1 | -- variation on https://gist.github.com/heptal/50998f66de5aba955c00
2 |
3 | local ampOnIcon = [[ASCII:
4 | .....1a..........AC..........E
5 | ..............................
6 | ......4.......................
7 | 1..........aA..........CE.....
8 | e.2......4.3...........h......
9 | ..............................
10 | ..............................
11 | .......................h......
12 | e.2......6.3..........t..q....
13 | 5..........c..........s.......
14 | ......6..................q....
15 | ......................s..t....
16 | .....5c.......................
17 | ]]
18 |
19 | local ampOffIcon = [[ASCII:
20 | .....1a.....x....AC.y.......zE
21 | ..............................
22 | ......4.......................
23 | 1..........aA..........CE.....
24 | e.2......4.3...........h......
25 | ..............................
26 | ..............................
27 | .......................h......
28 | e.2......6.3..........t..q....
29 | 5..........c..........s.......
30 | ......6..................q....
31 | ......................s..t....
32 | ...x.5c....y.......z..........
33 | ]]
34 |
35 | -- caffeine replacement
36 | local menubar = require"hs.menubar"
37 | local caffeinate = require"hs.caffeinate"
38 |
39 | local module = {}
40 |
41 | local function setIcon(state)
42 | module.menu:setIcon(state and ampOnIcon or ampOffIcon)
43 | end
44 |
45 | module.menu = menubar.new()
46 | module.menu:setClickCallback(function() setIcon(caffeinate.toggle("displayIdle")) end)
47 | setIcon(caffeinate.get("displayIdle"))
48 |
49 | return module
--------------------------------------------------------------------------------
/utils/_menus/applicationMenu.lua:
--------------------------------------------------------------------------------
1 | -- This example is for an Application launching menu Most of the necessary
2 | -- settings for this menu are already the defaults, but it serves as a simple
3 | -- example none-the-less.
4 |
5 | local FLM = require("hs._asm.filelistmenu")
6 |
7 | -- create the application menu and give it a default label
8 | local appMenu = FLM.new("Apps") ;
9 |
10 | -- The defaults for filelistmenu will create an Application based menu starting from
11 | -- the /Applications directory. The commands listed here are included so you can more
12 | -- easily see what is actually being setup, but they aren't really necessary for
13 | -- this default behavior, so they are commented out.
14 |
15 | -- Show an icon, if one is provided
16 | --appMenu:showForMenu("icon")
17 |
18 | -- The match criteria here is a string which matches any name which ends in .app. The
19 | -- parenthesis are included to indicate the portion of the name to use as the menu items
20 | -- label... without the parenthesis, the full name matched would be used.
21 | --appMenu:menuCriteria("^([^/]+)%.app$")
22 |
23 | -- This function indicates what action should occur when a menu item is selected
24 | --appMenu:actionFunction(function(x) hs.application.launchOrFocus(x) end)
25 |
26 | -- This function indicates what action should occur when a subfolder itself is selected
27 | --appMenu:folderFunction(function(x) os.execute([[open -a Finder "]]..x..[["]]) end)
28 |
29 | -- Specify the root directory to start from.
30 | --appMenu:rootDirectory("/Applications")
31 |
32 | -- The maximum folder depth that we will search for files or folders which match the
33 | -- criteria. This prevents potential loops, which would ultimately crash HS.
34 | appMenu:subFolderDepth(12)
35 |
36 | -- If false, then warning messages will not be printed to the HS console.
37 | appMenu:showWarnings(true)
38 |
39 | -- Define an icon using ASCIIArt. See hs.drawing and
40 | -- http://cocoamine.net/blog/2015/03/20/replacing-photoshop-with-nsstring/
41 | appMenu:menuIcon("ASCII:....................\n"..
42 | "............1..4....\n"..
43 | "....................\n"..
44 | "....................\n"..
45 | "....................\n"..
46 | "....................\n"..
47 | "....................\n"..
48 | "....................\n"..
49 | "....................\n"..
50 | "....................\n"..
51 | "....................\n"..
52 | "...B...............A\n"..
53 | "8...............9...\n"..
54 | "....................\n"..
55 | "....................\n"..
56 | "....................\n"..
57 | "...2...........5....\n"..
58 | "....................\n"..
59 | "...3..........6.....\n"..
60 | "....................")
61 |
62 | -- Sort folder items before file items in the menu
63 | appMenu:subFolders("before")
64 |
65 | -- activate the menu
66 | appMenu:activate()
67 |
68 | -- This allows you to include this file like 'menu = require(...)' and capture the
69 | -- menu object in case you want to manipulate it elsewhere.
70 |
71 | appMenu:itemImages(true)
72 |
73 | return appMenu
74 |
--------------------------------------------------------------------------------
/utils/_menus/documentsMenu.lua:
--------------------------------------------------------------------------------
1 | -- In this example we create a menu of the users Documents folder. We
2 | -- want to match all files and folders (except for dot-files)
3 |
4 | local FLM = require("hs._asm.filelistmenu")
5 | local hsfs = require("hs.fs")
6 | local eventtap = require("hs.eventtap")
7 |
8 | -- Here we define an action function which takes the modifiers pressed when the
9 | -- menu is clicked on so we can choose what action to perform. This action function
10 | -- is used for both Files and Folders
11 | local actionFunction = function(x)
12 | local mods = eventtap.checkKeyboardModifiers()
13 | if mods["cmd"] then
14 | os.execute([[/usr/local/bin/edit "]]..x..[["]])
15 | else
16 | os.execute([[open -a Finder "]]..x..[["]])
17 | end
18 | end
19 |
20 | local docMenu = FLM.new("Docs") ;
21 |
22 | -- Here we define the match criteria as a function. The function receives 3 arguments
23 | -- and returns up to 2. The arguments passed in are the file name (without path),
24 | -- the path (without the file at the end), and the purpose of this call, which will be
25 | -- "file" -- indicates we're matching files (i.e. menu end nodes)
26 | -- "directory" -- indicates we're matching folders (i.e. potential submenus)
27 | -- "update" -- indicates we're matching against the results of hs.pathwatcher for
28 | -- potential updates to the menu.
29 |
30 | -- Note that unlike a string criteria, when a function is used, file matches are not
31 | -- automatically exempted from subfolder matches -- this allows more flexibility when
32 | -- it comes to OS X bundle types (like .app)
33 |
34 | -- Returns 'boolean, label' where boolean will be true if we should consider this file
35 | -- a match or false if we should skip it. Label is what will be put in the menu and is
36 | -- optional when the boolean value is false.
37 | docMenu:menuCriteria(function(file, path, purpose)
38 |
39 | -- ignore dot files
40 | if string.match(file, "^%..*$") then return false end
41 |
42 | -- For file checks, we want to ignore directories
43 | if purpose == "file" then
44 | if hsfs.attributes(path.."/"..file, "mode") == "directory" then return false end
45 | return true, file -- otherwise, return true and file as label
46 |
47 | -- We want all folders as well, when looking for them
48 | elseif purpose == "directory" then
49 | if hsfs.attributes(path.."/"..file, "mode") == "directory" then return true, file end
50 | return false -- otherwise, return false
51 |
52 | -- And any update which makes it this far should also be accepted
53 | elseif purpose == "update" then
54 | return true, file
55 | end
56 | end
57 | )
58 |
59 | docMenu:actionFunction(actionFunction)
60 | docMenu:folderFunction(actionFunction)
61 | docMenu:rootDirectory(os.getenv("HOME").."/Documents")
62 |
63 | docMenu:showWarnings(false)
64 |
65 | docMenu:menuIcon("ASCII:....................\n"..
66 | "....................\n"..
67 | "...c........c.......\n"..
68 | "...dt....tri12......\n"..
69 | "....v...............\n"..
70 | "...............3....\n"..
71 | "...........i...4b...\n"..
72 | "..........rg...g....\n"..
73 | "..........p...pm....\n"..
74 | "....................\n"..
75 | "....................\n"..
76 | "....................\n"..
77 | "....................\n"..
78 | "....................\n"..
79 | "....................\n"..
80 | "....v..........m....\n"..
81 | "...dk..........kb...\n"..
82 | "...a............a...\n"..
83 | "....................\n"..
84 | "....................")
85 |
86 | docMenu:subFolders("mixed")
87 |
88 | --docMenu:activate()
89 |
90 | return docMenu
--------------------------------------------------------------------------------
/utils/_panels/infoPanel.lua:
--------------------------------------------------------------------------------
1 | local slidingPanels = hs.loadSpoon("SlidingPanels")
2 |
3 | slidingPanels:addPanel("infoPanel", {
4 | side = "top",
5 | size = 1/3,
6 | modifiers = { "fn" },
7 | persistent = true,
8 | animationDuration = 0.1,
9 | color = { white = .35 },
10 | fillAlpha = .95,
11 | }):enable()
12 |
13 | -- the "FromSpoon" widget takes the following arguments:
14 | --
15 | -- * spoonName - string
16 | -- * frameDetails - table containing frameDetails describing where to place canvas within panel (see guitk.manager)
17 | -- * spoonConfig - table
18 | -- * canvas - string specifying the name of the canvas as stored within the spoon (usually "canvas" or similar)
19 | -- * start - string naming method to invoke to start/show/build the canvas or function(spoon) ... end which does the starting
20 | -- * vars - table of key-value pairs for spoon to be set before "start", if present, is invoked
21 | -- * background - a table specifying a canvas element, e.g. a rectangle or an image, to use as the background for the spoon canvas. This can be useful to provide contrast if the spoon's coloring is hard to see against the panel's background.
22 |
23 | slidingPanels:panel("infoPanel"):addWidget("FromSpoon", "HCalendar", { rX = "100%", bY = "100%" })
24 |
25 | slidingPanels:panel("infoPanel"):addWidget("FromSpoon", "CircleClock", { rX = "100%", y = 0 }, {
26 | background = {
27 | type = "rectangle",
28 | action = "fill",
29 | roundedRectRadii = { xRadius = 20, yRadius = 20 },
30 | fillColor = { red = .4, blue = .32, green = .32, alpha = .7 },
31 | },
32 | })
33 |
34 | slidingPanels:panel("infoPanel"):addWidget("FromSpoon", "MountedVolumes", { x = 0, bY = "100%" }, {
35 | start = function(spoon)
36 | spoon.textStyle.font.size = 9 -- easier then spelling out entire style in vars
37 | -- need to think about separating out font from style in spoon
38 | spoon:show()
39 | end,
40 | vars = { cornerRadius = 20, },
41 | })
42 |
43 | slidingPanels:panel("infoPanel"):addWidget("FromSpoon", "CPUMEMBAT", { x = 0, y = 0 }, {
44 | start = "show", -- could also be `function(spoon) spoon:show() end`
45 | vars = {
46 | checkInterval = 10,
47 | baseFont = { name = "Menlo", size = 10 },
48 | },
49 | })
50 |
51 | return slidingPanels:panel("infoPanel")
52 |
--------------------------------------------------------------------------------
/utils/gc.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 |
3 | local seen_GCs = {}
4 |
5 | local __gc_replacement = function(modName, originalFN)
6 | seen_GCs[modName] = originalFN
7 | return function(...)
8 | -- print("~~ " .. os.date("%Y-%m-%d %H:%M:%S") .. " : invoking " .. tostring(modName) .. ".__gc")
9 | print("~~ " .. timestamp() .. " : invoking " .. tostring(modName) .. ".__gc")
10 | originalFN(...)
11 | end
12 | end
13 |
14 | module.patch = function(k)
15 | local mt = hs.getObjectMetatable(k)
16 | if mt and mt.__name and not mt.__gc then
17 | -- does nothing because the object had no __gc, but we need something for this to work
18 | mt.__gc = function(self) end
19 | end
20 | if mt and type(mt.__gc) == "function" then
21 | if type(seen_GCs[k]) == "function" then
22 | print("~~ " .. tostring(k) .. " already patched")
23 | else
24 | seen_GCs[k] = mt.__gc
25 | print("~~ patching " .. tostring(k))
26 | mt.__gc = __gc_replacement(k, mt.__gc)
27 | return true
28 | end
29 | else
30 | print("~~ " .. tostring(k) .. " does not have a registered metatable with a __gc function")
31 | end
32 | return false
33 | end
34 |
35 | -- note this can make garbage collection *VERY* slow if you haven't previously ignored a lot of things.
36 | -- better to call `patch` on the specific ones you want to watch
37 | module.patchAll = function()
38 | for k, v in pairs(debug.getregistry()) do
39 | if type(v) == "table" then
40 | if type(v.__gc) == "function" and not seen_GCs[k] then
41 | module.patch(k)
42 | elseif type(seen_GCs[k]) == "boolean" then
43 | print("~~ skipping " .. tostring(k))
44 | end
45 | end
46 | end
47 | end
48 |
49 | module.revert = function(k)
50 | if type(seen_GCs[k]) == "function" then
51 | local mt = hs.getObjectMetatable(k)
52 | if mt then
53 | mt.__gc = seen_GCs[k]
54 | seen_GCs[k] = true
55 | print("~~ reverting " .. tostring(k))
56 | return true
57 | else
58 | print("~~ " .. tostring(k) .. " does not have a metatable")
59 | end
60 | else
61 | print("~~ " .. tostring(k) .. " is not patched")
62 | end
63 | return false
64 | end
65 |
66 | module.ignore = function(...)
67 | local args = table.pack(...)
68 | if type(args[1]) == "table" and args.n == 1 then
69 | args = args[1]
70 | end
71 | for i, v in ipairs(args) do
72 | if type(seen_GCs[v]) == "function" then
73 | module.revert(v)
74 | end
75 | print("~~ ignoring " .. tostring(v))
76 | seen_GCs[v] = true
77 | end
78 | end
79 |
80 | module.__originals = seen_GCs
81 |
82 | return module
83 |
--------------------------------------------------------------------------------
/utils/watchables.lua:
--------------------------------------------------------------------------------
1 | local module = {}
2 |
3 | -- common watchers... why replicate what so many of my "modlets" care about?
4 |
5 | local reachability = require"hs.network.reachability"
6 | local screen = require"hs.screen"
7 | local watchable = require"hs.watchable"
8 | local caffeinate = require"hs.caffeinate"
9 | local configuration = require"hs.network.configuration"
10 |
11 | module.generalStatus = watchable.new("generalStatus")
12 |
13 | module.generalStatus.internet = (reachability.internet():status() & reachability.flags.reachable) > 0
14 | module.internetWatcher = reachability.internet():setCallback(function(obj, status)
15 | module.generalStatus.internet = (status & reachability.flags.reachable) > 0
16 | end):start()
17 |
18 | module.generalStatus.activeScreenChanges = 0
19 | module.generalStatus.activeSpaceChanges = 0
20 | module.activeScreenSpaceWatcher = screen.watcher.newWithActiveScreen(function(screenOrSpace)
21 | if screenOrSpace then
22 | module.generalStatus.activeScreenChanges = module.generalStatus.activeScreenChanges + 1
23 | else
24 | module.generalStatus.activeSpaceChanges = module.generalStatus.activeSpaceChanges + 1
25 | end
26 | end):start()
27 |
28 | module.generalStatus.caffeinatedState = 0
29 | module.caffeinatedStateWatcher = caffeinate.watcher.new(function(event)
30 | module.generalStatus.caffeinatedState = event
31 | end):start()
32 |
33 | local vpnQueryKey = "State:/Network/Interface/utun[0-9]+/IPv4"
34 | local verifyOurVPNisUp = function()
35 | local status = false
36 | if module.vpnWatcher then
37 | for k, v in pairs(module.vpnWatcher:contents(vpnQueryKey, true)) do
38 | for i2, v2 in ipairs(v["Addresses"]) do
39 | if v2:match("^10%.161%.82%.") then
40 | status = true
41 | break
42 | end
43 | end
44 | if status then break end
45 | end
46 | end
47 | module.generalStatus.privateVPN = status
48 | end
49 | module.vpnWatcher = configuration.open():setCallback(verifyOurVPNisUp)
50 | :monitorKeys(vpnQueryKey, true)
51 | :start()
52 | verifyOurVPNisUp()
53 |
54 | return module
55 |
--------------------------------------------------------------------------------