നിങ്ങൾ ഒരു നെർഡ് ആണെങ്കിൽ, കൂടാതെ മാക്കുകളുമായി കുറച്ചുകാലമായി ബന്ധപ്പെട്ടിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് Applescript ഓർമ്മയുണ്ടാകാം. മാക് ആപ്ലിക്കേഷനുകളെ നിയന്ത്രിക്കാൻ ഇന്റർമീഡിയറ്റ് മുതൽ അഡ്വാൻസ്ഡ് ഉപയോക്താക്കൾക്ക് ലളിതമായ സ്ക്രിപ്റ്റുകൾ എഴുതാൻ Apple വികസിപ്പിച്ച ഒരു ഭാഷയായിരുന്നു ഇത്. ഇത് ഇംഗ്ലീഷ് ഭാഷയെ പോലെയാക്കാൻ സൃഷ്ടിച്ചതാണ്, അതിനാൽ ഒരു പിക്സൽ ആക്സസ് ചെയ്യുന്നത് ഇങ്ങനെ എഴുതാം:

pixel 7 of row 3 of TIFF image "my bitmap"

അല്ലെങ്കിൽ

TIFF image "my bitmap"'s 3rd row's 7th pixel

പറയേണ്ടതില്ല, ആധുനിക പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഇതുപോലെ കാണപ്പെടാത്തതിന് ഒരു നല്ല കാരണമുണ്ട്: ഇത് സ്കെയിൽ ചെയ്യുന്നില്ല. Applescript-ൽ വലിയ കാലയളവ് പ്രവർത്തിച്ചിട്ടുള്ള ആർക്കും ഇതിന്റെ പരിമിതികൾ എത്ര വേഗത്തിൽ കണ്ടുമുട്ടാമെന്ന് അറിയാം. Apple 2016-ൽ ഇത് അനൗദ്യോഗികമായി നിരാകരിച്ചു, സ്രഷ്ടാവായ Sal Soghoian-നെ “ബിസിനസ് കാരണങ്ങൾ” കാരണം പുറത്താക്കിയപ്പോൾ.

Applescript താഴ്ന്നുകൊണ്ടിരിക്കെ, Steven എന്ന ഒരു ജ്ഞാനി Hammerspoon എഴുതുകയായിരുന്നു, macOS API-യിലേക്കുള്ള ഒരു Lua ബ്രിഡ്ജ്. ലളിതവും ആധുനികവുമായ ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയായ Lua ഇതിന് തികഞ്ഞ ഫിറ്റായിരുന്നു. അതിനാൽ, ഇത് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നോക്കാം.

Hammerspoon ഇൻസ്റ്റാൾ ചെയ്യുന്നു

Homebrew ഉപയോഗിക്കുക.

brew install hammerspoon

സജ്ജീകരണം

~/.hammerspoon/init.lua എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുക.

mkdir ~/.hammerspoon && touch ~/.hammerspoon/init.lua

ആപ്പ് തുറക്കുക.

open -a Hammerspoon

നിങ്ങൾക്ക് ഇതുപോലെ ഒരു Lua കൺസോൾ കാണാൻ കഴിയും (ഉള്ളടക്കത്തെക്കുറിച്ച് വിഷമിക്കേണ്ട).

പ്രിഫറൻസുകൾ ക്ലിക്ക് ചെയ്ത്, ആക്സസിബിലിറ്റി പ്രവർത്തനക്ഷമമാണെന്ന് ഉറപ്പാക്കുക.

നിങ്ങൾക്ക് ആഗ്രഹമുണ്ടെങ്കിൽ, ലോഗിൻ ചെയ്യുമ്പോൾ Hammerspoon തുറക്കുക എന്നതും പരിശോധിക്കാം.

init.lua പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കൽ

നിങ്ങൾ സൃഷ്ടിച്ച init.lua ഫയലിൽ താഴെയുള്ളത് പേസ്റ്റ് ചെയ്യുക.

local logger = hs.logger.new("init.lua", "debug")
logger.d("SUCCESSFULLY RAN init.lua")

ഫയൽ സേവ് ചെയ്ത്, കൺസോളിലെ Reload ബട്ടൺ അമർത്തുക. ഔട്പുട്ട് കാണുന്നുവെങ്കിൽ, നിങ്ങൾ തയ്യാറാണ്.

സിസ്റ്റം വ്യാപക ഹോട്ട്കീകൾ ബൈൻഡ് ചെയ്യുന്നു

ഞാൻ Hammerspoon ഉപയോഗിക്കുന്ന പ്രധാന കാര്യം “സ്മാർട്ട്” ഹോട്ട്കീകൾ സൃഷ്ടിക്കുക എന്നതാണ്, Preferences-ൽ ഉള്ള ബഗ്ഗി ഹോട്ട്കീകൾ മാറ്റാതെയോ Karabiner പോലുള്ള മറ്റൊരു ആപ്പ് ഡൗൺലോഡ് ചെയ്യാതെയോ. ഇവിടെ ചില സ്റ്റാർട്ടർ ഫംഗ്ഷനുകൾ നൽകിയിരിക്കുന്നു, അവ നിങ്ങൾക്ക് init.lua-ൽ ഇടാൻ കഴിയും, അത് പുതിയ ഹോട്ട്കീകൾ സൃഷ്ടിക്കുന്നത് വളരെ ലളിതമാക്കും.

local function stringsplit(inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t = {}
	for str in string.gmatch(inputstr, "([^" .. sep .. "]+)") do
		table.insert(t, str)
	end
	return t
end

local function keyMapArray(global_modifiers, mappings)
	for k, v in pairs(mappings) do
		if type(v) == "string" then
			-- ഞങ്ങൾ മാപ്പ് ചെയ്യുന്ന മോഡിഫയറുകൾ
			local modifiers = {}
			local splitkey = stringsplit(v, "-")

			local splitlen = #splitkey
			-- v-ൽ അടങ്ങിയിരിക്കുന്ന മാപ്പ് ചെയ്ത മോഡിഫയറുകൾ മോഡിഫയർ അറേയിലേക്ക് ചേർക്കുക
			for i = 1, splitlen - 1 do
				modifiers[i] = splitkey[i]
			end

			-- ബൈൻഡ് ഫംഗ്ഷനിലേക്ക് പാസ് ചെയ്യാനുള്ള നമ്പർ കീകോഡ് ഇത് ലഭിക്കുന്നു
			local mappedKeyCode = hs.keycodes.map[splitkey[splitlen]]
			if mappedKeyCode then
				hs.hotkey.bind(global_modifiers, k, function()
					hs.eventtap.keyStroke(modifiers, mappedKeyCode, 1)
				end)
			else
				-- നമ്പർ കീകോഡ് നിൽക്കുന്നു, അതായത് അത് നിലവിലില്ല
				-- ഇപ്പോൾ ഞങ്ങൾ അതിനെ സിസ്റ്റം കീ ഇവന്റ് കോഡായി കണക്കാക്കാൻ ശ്രമിക്കുന്നു, ഉദാഹരണത്തിന്
				-- PLAY
				hs.hotkey.bind(global_modifiers, k, function()
					hs.eventtap.event.newSystemKeyEvent(v, true):post()
					hs.eventtap.event.newSystemKeyEvent(v, false):post()
				end)
			end
		elseif type(v) == "function" then
			hs.hotkey.bind(global_modifiers, k, v)
		end
	end
end

local function processMaps(maps)
	for globals, mappings in pairs(maps) do
		keyMapArray(globals, mappings)
	end
end

നിങ്ങൾക്ക് Lua-യിൽ പരിചയമില്ലെങ്കിൽ ഭയപ്പെടേണ്ട, വിഷമിക്കേണ്ട. ഈ ഫംഗ്ഷന്റെ ഉദ്ദേശ്യം Lua പഠിക്കാതെ തന്നെ നിങ്ങളെ ആരംഭിപ്പിക്കുക എന്നതാണ്. ഒരു പുതിയ മാപ്പിംഗ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് നോക്കാം. നിങ്ങൾക്ക് Vim ആരോ കീ ബൈൻഡിംഗുകൾ സിസ്റ്റം വ്യാപകമായി ആവശ്യമുണ്ടെന്ന് കരുതുക, ctrl ഉപയോഗിച്ച് സജീവമാക്കുക.

-- മാപ്പിംഗുകൾ നിർവചിക്കുക
local maps = {
	[{ "ctrl" }] = {
		-- ആരോ കീകൾ
		["h"] = "left",
		["j"] = "down",
		["k"] = "up",
		["l"] = "right",
	},
}

-- മാപ്പിംഗുകൾ ബൈൻഡ് ചെയ്യുക
processMaps(maps)

ഇത് ഫയലിന്റെ അടിയിൽ ഇടുക, കോൺഫിഗ് റീലോഡ് ചെയ്യുക, നിങ്ങളുടെ കീകൾ മാപ്പ് ചെയ്യപ്പെടും!

maps എങ്ങനെ പ്രവർത്തിക്കുന്നു

maps ഒരു അറേ ആണ്, അല്ലെങ്കിൽ ടേബിളുകളുടെ ഒരു ലിസ്റ്റ്. ഓരോ ടേബിളിനും അതിന്റെ കീയായി മോഡിഫയർ കീകളുടെ ഒരു അറേ ഉണ്ട്, കൂടാതെ ഒരു കീയെ മറ്റൊരു കീയിലേക്ക് മാപ്പ് ചെയ്യുന്ന ഒരു ടേബിൾ അതിന്റെ മൂല്യമായി ഉണ്ട്. മുകളിലെ ഉദാഹരണത്തിൽ, ഒരേയൊരു മോഡിഫയർ കീ ctrl ആണ്, അതായത് അതിന്റെ ടേബിളിലെ എല്ലാ മാപ്പിംഗുകളും ctrl പിടിച്ചിരിക്കുമ്പോൾ മാത്രമേ സജീവമാകൂ. തുടർന്ന് അത് h എന്നത് ഇടത് ആരോയിലേക്കും, j എന്നത് താഴേക്ക് ആരോയിലേക്കും മാപ്പ് ചെയ്യുന്നു.

നിങ്ങൾക്ക് ഇപ്പോഴും മനസ്സിലാകുന്നില്ലെങ്കിൽ, വിഷമിക്കേണ്ട. ഈ ഉദാഹരണങ്ങൾ നോക്കി നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമാക്കുക.

ഉദാഹരണങ്ങൾ

ഇവിടെ maps tables ന്റെ കുറച്ച് ഉദാഹരണങ്ങൾ കൂടി ഉണ്ട്:

ctrl-n വാക്ക് ഡിലീറ്റ് ചെയ്യാൻ, ctrl-m കാരക്ടർ ഡിലീറ്റ് ചെയ്യാൻ, ctrl-. കഴ്സറിന് മുന്നിലുള്ള വാക്ക് ഡിലീറ്റ് ചെയ്യാൻ, ctrl-, കഴ്സറിന് മുന്നിലുള്ള കാരക്ടർ ഡിലീറ്റ് ചെയ്യാൻ മാപ്പ് ചെയ്യുക.

-- inside `maps`
[{ "ctrl" }] = {
	-- Deleting
	["n"] = "alt-delete",
	["m"] = "delete",
	[","] = "forwarddelete",
	["."] = "alt-forwarddelete",
},

ഫംഗ്ഷൻ കീകൾ മീഡിയ കൺട്രോളുകളായി മാപ്പ് ചെയ്യുക. ഇവയ്ക്ക് മോഡിഫയർ കീകൾ ഇല്ലാത്തതിനാൽ, f1 അമർത്തിയാൽ മാത്രം ബൈൻഡിംഗ് സജീവമാകും:

-- inside `maps`
[{}] = {
	-- Media controls
	["f1"] = "MUTE",
	["f2"] = "SOUND_DOWN",
	["f3"] = "SOUND_UP",

	["f5"] = "PREVIOUS",
	["f6"] = "PLAY",
	["f7"] = "NEXT",
},

നിങ്ങളുടെ Hammerspoon കോൺഫിഗ് alt-ctrl-r ഉപയോഗിച്ച് റീലോഡ് ചെയ്യുക

-- inside `maps`
[{ "alt", "ctrl" }] = {
	-- Reload Hammerspoon config
	["r"] = hs.reload,
},

നിങ്ങളുടെ ലാപ്ടോപ്പ് cmd-g ഉപയോഗിച്ച് സ്ലീപ്പ് മോഡിലേക്ക് മാറ്റുക

-- inside `maps`
[{ "cmd" }] = {
	["g"] = function()
		-- This function executes a shell command
		os.execute("pmset sleepnow")
	end,
},

Obsidian ആപ്പ് cmd-shift-o ഉപയോഗിച്ച് ലോഞ്ച് ചെയ്യുക

[{ "cmd", "shift" }] = {
	["o"] = function()
		hs.application.launchOrFocus("Obsidian")
	end,
},

എല്ലാം നിർവചിച്ച ശേഷം processMaps(maps) റൺ ചെയ്യാൻ ഓർക്കുക!

local maps = {
	[{}] = {
		-- stuff
	},
	[{ "cmd" }] = {
		-- stuff
	},
	[{ "cmd", "shift" }] = {
		-- stuff
	},
	-- ...
}

processMaps(maps)

ഉപസംഹാരം

Hammerspoon ഒരു അത്യന്തം ശക്തമായ ഉപകരണമാണ്. Lua ഭാഷയിൽ പരിചയം സമ്പാദിച്ചാൽ, സാധ്യതകൾ അനന്തമാണ്. ഈ പോസ്റ്റിൽ ഞാൻ ഹോട്ട്കീകളിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിച്ചു, കാരണം Hammerspoon-ന്റെ ഏറ്റവും വലിയ ഉപയോഗ കേസ് ഇതാണെന്ന് ഞാൻ കണ്ടെത്തി.

Hammerspoon എക്സ്പോസ് ചെയ്യുന്ന എല്ലാ API ഫംഗ്ഷനുകളും കാണാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, അവരുടെ ഡോക്യുമെന്റേഷൻ പരിശോധിക്കുക. ഈ ആപ്പ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന കാര്യങ്ങളുടെ എണ്ണം അതിശയോക്തിപരമാണ്—ഉദാഹരണത്തിന് ബാറ്ററി സ്റ്റാറ്റസിലേക്ക് ഇവന്റുകൾ ബൈൻഡ് ചെയ്യുക, ഡിസ്പ്ലേ ബ്രൈറ്റ്നസ് മാറ്റുക, ഡയലോഗ് പ്രോംപ്റ്റുകൾ തുറക്കുക, HTTP അഭ്യർത്ഥനകൾ അയയ്ക്കുക, കോപ്പി ചെയ്യുകയും പേസ്റ്റ് ചെയ്യുകയും, തുടങ്ങിയവ. ഇതിന് പുറമേ, Luarocks വഴി മുഴുവൻ Lua ഇക്കോസിസ്റ്റത്തിന്റെ പ്രയോജനം നിങ്ങൾക്ക് എടുക്കാം.

കൂടാതെ, മറ്റ് ആരാധകർ എന്താണ് ചെയ്യുന്നതെന്ന് കാണാൻ r/Hammerspoon പരിശോധിക്കുക. അവിടെ കുറച്ച് കൂടുതൽ അംഗങ്ങൾ ഉണ്ടായിരിക്കുന്നത് നല്ലതാണ് :)

ഉപയോഗപ്രദമായ ലിങ്കുകൾ

Hammerspoon-നെ സംബന്ധിച്ച വിവിധ വിഭവങ്ങളുടെ ഒരു ശേഖരണം. പുതിയ കാര്യങ്ങൾ കണ്ടെത്തുമ്പോൾ ഇത് അപ്ഡേറ്റ് ചെയ്യും.