added NextWindowTags event handling
[wmiirc-lua.git] / core / wmii.lua
blob98f46c686abb26608c78950224049f5a2ea75140
1 --
2 -- Copyright (c) 2007, Bart Trojanowski <bart@jukie.net>
3 --
4 -- WMII event loop, in lua
5 --
6 -- http://www.jukie.net/~bart/blog/tag/wmiirc-lua
7 -- git://www.jukie.net/wmiirc-lua.git/
8 --
10 -- ========================================================================
11 -- DOCUMENTATION
12 -- ========================================================================
13 --[[
14 =pod
16 =head1 NAME
18 wmii.lua - WMII event-loop methods in lua
20 =head1 SYNOPSIS
22 require "wmii"
24 -- Write something to the wmii filesystem, in this case a key event.
25 wmii.write ("/event", "Key Mod1-j")
27 -- Set your wmii /ctl parameters
28 wmii.set_ctl({
29 font = '....'
32 -- Configure wmii.lua parameters
33 wmii.set_conf ({
34 xterm = 'x-terminal-emulator'
37 -- Now start the event loop
38 wmii.run_event_loop()
40 =head1 DESCRIPTION
42 wmii.lua provides methods for replacing the stock sh-based wmiirc shipped with
43 wmii 3.6 and newer with a lua-based event loop.
45 It should be used by your wmiirc
47 =head1 METHODS
49 =over 4
51 =cut
52 --]]
54 -- ========================================================================
55 -- MODULE SETUP
56 -- ========================================================================
58 local wmiidir = os.getenv("HOME") .. "/.wmii-3.5"
59 local wmiirc = wmiidir .. "/wmiirc"
61 package.path = wmiidir .. "/core/?.lua;" ..
62 wmiidir .. "/plugins/?.lua;" ..
63 package.path
64 package.cpath = wmiidir .. "/core/?.so;" ..
65 wmiidir .. "/plugins/?.so;" ..
66 package.cpath
68 local ixp = require "ixp"
69 local eventloop = require "eventloop"
70 local history = require "history"
72 local io = require("io")
73 local os = require("os")
74 local string = require("string")
75 local table = require("table")
76 local math = require("math")
77 local type = type
78 local error = error
79 local print = print
80 local pcall = pcall
81 local pairs = pairs
82 local package = package
83 local require = require
84 local tostring = tostring
85 local tonumber = tonumber
86 local setmetatable = setmetatable
88 -- kinda silly, but there is no working liblua5.1-posix0 in ubuntu
89 -- so we make it optional
90 local have_posix, posix = pcall(require,"posix")
92 module("wmii")
94 -- get the process id
95 local myid
96 if have_posix then
97 -- but having posix is not enough as the API changes, so we try each one
98 if posix.getprocessid then
99 local stat,rc = pcall (posix.getprocessid, "pid")
100 if stat then
101 myid = rc
104 if not myid and posix.getpid then
105 local stat,rc = pcall (posix.getpid, "pid")
106 if stat then
107 myid = rc
111 if not myid then
112 -- we were not able to get the PID, but we can create a random number
113 local now = tonumber(os.date("%s"))
114 math.randomseed(now)
115 myid = math.random(10000)
118 -- ========================================================================
119 -- MODULE VARIABLES
120 -- ========================================================================
122 -- wmiir points to the wmiir executable
123 -- TODO: need to make sure that wmiir is in path, and if not find it
124 local wmiir = "wmiir"
126 -- wmii_adr is the address we use when connecting using ixp
127 local wmii_adr = os.getenv("WMII_ADDRESS")
128 or ("unix!/tmp/ns." .. os.getenv("USER") .. "."
129 .. os.getenv("DISPLAY"):match("(:%d+)") .. "/wmii")
131 -- wmixp is the ixp context we use to talk to wmii
132 local wmixp = ixp.new(wmii_adr)
134 -- history of previous views, view_hist[#view_hist] is the last one
135 local view_hist = {} -- sorted with 1 being the oldest
136 local view_hist_max = 50 -- max number to keep track of
138 -- allow for a client to be forced to a tag
139 local next_client_goes_to_tag = nil
141 -- program and action histories
142 local prog_hist = history.new (20)
143 local action_hist = history.new(10)
145 -- where to find plugins
146 plugin_path = os.getenv("HOME") .. "/.wmii-3.5/plugins/?.so;"
147 .. os.getenv("HOME") .. "/.wmii-3.5/plugins/?.lua;"
148 .. "/usr/local/lib/lua/5.1/wmii/?.so;"
149 .. "/usr/local/share/lua/5.1/wmii/?.lua;"
150 .. "/usr/lib/lua/5.1/wmii/?.so;"
151 .. "/usr/share/lua/5.1/wmii/?.lua"
153 -- where to find wmiirc (see find_wmiirc())
154 wmiirc_path = os.getenv("HOME") .. "/.wmii-3.5/wmiirc.lua;"
155 .. os.getenv("HOME") .. "/.wmii-3.5/wmiirc;"
156 .. "/etc/X11/wmii-3.5/wmiirc.lua;"
157 .. "/etc/X11/wmii-3.5/wmiirc"
159 -- ========================================================================
160 -- LOCAL HELPERS
161 -- ========================================================================
163 --[[
164 =pod
166 =item log ( str )
168 Log the message provided in C<str>
170 Currently just writes to io.stderr
172 =cut
173 --]]
174 function log (str)
175 if get_conf("debug") then
176 io.stderr:write (str .. "\n")
180 --[[
181 =pod
183 =item find_wmiirc ( )
185 Locates the wmiirc script. It looks in ~/.wmii-3.5 and /etc/X11/wmii-3.5
186 for the first lua script bearing the name wmiirc.lua or wmiirc. Returns
187 first match.
189 =cut
190 --]]
191 function find_wmiirc()
192 local fn
193 for fn in string.gmatch(wmiirc_path, "[^;]+") do
194 -- try to locate the files locally
195 local file = io.open(fn, "r")
196 if file then
197 local txt = file:read("*line")
198 file:close()
199 if type(txt) == 'string' and txt:match("lua") then
200 return fn
204 return nil
208 -- ========================================================================
209 -- MAIN ACCESS FUNCTIONS
210 -- ========================================================================
212 --[[
213 =pod
215 =item ls ( dir, fmt )
217 List the wmii filesystem directory provided in C<dir>, in the format specified
218 by C<fmt>.
220 Returns an iterator of TODO
222 =cut
223 --]]
224 function ls (dir, fmt)
225 local verbose = fmt and fmt:match("l")
227 local s = wmixp:stat(dir)
228 if not s then
229 return function () return nil end
231 if s.modestr:match("^[^d]") then
232 return function ()
233 return stat2str(verbose, s)
237 local itr = wmixp:idir (dir)
238 if not itr then
239 --return function ()
240 return nil
241 --end
245 return function ()
246 local s = itr()
247 if s then
248 return stat2str(verbose, s)
250 return nil
254 local function stat2str(verbose, stat)
255 if verbose then
256 return string.format("%s %s %s %5d %s %s", stat.modestr, stat.uid, stat.gid, stat.length, stat.timestr, stat.name)
257 else
258 if stat.modestr:match("^d") then
259 return stat.name .. "/"
260 else
261 return stat.name
266 -- ------------------------------------------------------------------------
267 -- read all contents of a wmii virtual file
268 function read (file)
269 return wmixp:read (file)
272 -- ------------------------------------------------------------------------
273 -- return an iterator which walks all the lines in the file
275 -- example:
276 -- for event in wmii.iread("/ctl")
277 -- ...
278 -- end
280 -- NOTE: don't use iread for files that could block, as this will interfere
281 -- with timer processing and event delivery. Instead fork off a process to
282 -- execute wmiir and read back the responses via callback.
283 function iread (file)
284 return wmixp:iread(file)
287 -- ------------------------------------------------------------------------
288 -- create a wmii file, optionally write data to it
289 function create (file, data)
290 wmixp:create(file, data)
293 -- ------------------------------------------------------------------------
294 -- remove a wmii file
295 function remove (file)
296 wmixp:remove(file)
299 -- ------------------------------------------------------------------------
300 -- write a value to a wmii virtual file system
301 function write (file, value)
302 wmixp:write (file, value)
305 -- ------------------------------------------------------------------------
306 -- setup a table describing dmenu command
307 local function dmenu_cmd (prompt, iterator)
308 local cmdt = { "dmenu", "-b" }
309 local fn = get_ctl("font")
310 if fn then
311 cmdt[#cmdt+1] = "-fn"
312 cmdt[#cmdt+1] = fn
314 local normcolors = get_ctl("normcolors")
315 if normcolors then
316 local nf, nb = normcolors:match("(#%x+)%s+(#%x+)%s#%x+")
317 if nf then
318 cmdt[#cmdt+1] = "-nf"
319 cmdt[#cmdt+1] = "'" .. nf .. "'"
321 if nb then
322 cmdt[#cmdt+1] = "-nb"
323 cmdt[#cmdt+1] = "'" .. nb .. "'"
326 local focuscolors = get_ctl("focuscolors")
327 if focuscolors then
328 local sf, sb = focuscolors:match("(#%x+)%s+(#%x+)%s#%x+")
329 if sf then
330 cmdt[#cmdt+1] = "-sf"
331 cmdt[#cmdt+1] = "'" .. sf .. "'"
333 if sb then
334 cmdt[#cmdt+1] = "-sb"
335 cmdt[#cmdt+1] = "'" .. sb .. "'"
338 if prompt then
339 cmdt[#cmdt+1] = "-p"
340 cmdt[#cmdt+1] = "'" .. prompt .. "'"
343 return cmdt
346 -- ------------------------------------------------------------------------
347 -- displays the menu given an table of entires, returns selected text
348 function menu (tbl, prompt)
349 local dmenu = dmenu_cmd(prompt)
351 local infile = os.tmpname()
352 local fh = io.open (infile, "w+")
354 local i,v
355 for i,v in pairs(tbl) do
356 if type(i) == 'number' and type(v) == 'string' then
357 fh:write (v)
358 else
359 fh:write (i)
361 fh:write ("\n")
363 fh:close()
365 local outfile = os.tmpname()
367 dmenu[#dmenu+1] = "<"
368 dmenu[#dmenu+1] = infile
369 dmenu[#dmenu+1] = ">"
370 dmenu[#dmenu+1] = outfile
372 local cmd = table.concat(dmenu," ")
373 os.execute (cmd)
375 fh = io.open (outfile, "r")
376 os.remove (outfile)
378 local sel = fh:read("*l")
379 fh:close()
381 return sel
384 -- ------------------------------------------------------------------------
385 -- displays the a tag selection menu, returns selected tag
386 function tag_menu ()
387 local tags = get_tags()
389 return menu(tags, "tag:")
392 -- ------------------------------------------------------------------------
393 -- displays the a program menu, returns selected program
394 function prog_menu ()
395 local dmenu = dmenu_cmd("cmd:")
397 local outfile = os.tmpname()
399 dmenu[#dmenu+1] = ">"
400 dmenu[#dmenu+1] = outfile
402 local hstt = { }
403 for n in prog_hist:walk_reverse_unique() do
404 hstt[#hstt+1] = "echo '" .. n .. "' ; "
407 local cmd = "(" .. table.concat(hstt)
408 .. "dmenu_path ) |"
409 .. table.concat(dmenu," ")
410 os.execute (cmd)
412 local fh = io.open (outfile, "rb")
413 os.remove (outfile)
415 local prog = fh:read("*l")
416 io.close (fh)
418 return prog
421 -- ------------------------------------------------------------------------
422 -- returns a table of all tags
423 function get_tags()
424 local t = {}
425 local s
426 for s in wmixp:idir ("/tag") do
427 if s.name and not (s.name == "sel") then
428 t[#t + 1] = s.name
431 table.sort(t)
432 return t
435 -- ------------------------------------------------------------------------
436 -- returns the selected tag (the view)
437 function get_view()
438 local v = wmixp:read("/ctl") or ""
439 return v:match("view%s+(%S+)")
442 -- ------------------------------------------------------------------------
443 -- changes the current view to the name given
444 function set_view(sel)
445 local cur = get_view()
446 local all = get_tags()
448 if #all < 2 or sel == cur then
449 -- nothing to do if we have less then 2 tags
450 return
453 if not (type(sel) == "string") then
454 error ("string argument expected")
457 -- set new view
458 write ("/ctl", "view " .. sel)
461 -- ------------------------------------------------------------------------
462 -- changes the current view to the index given
463 function set_view_index(sel)
464 local cur = get_view()
465 local all = get_tags()
467 if #all < 2 then
468 -- nothing to do if we have less then 2 tags
469 return
472 local num = tonumber (sel)
473 if not num then
474 error ("number argument expected")
477 local name = all[sel]
478 if not name or name == cur then
479 return
482 -- set new view
483 write ("/ctl", "view " .. name)
486 -- ------------------------------------------------------------------------
487 -- chnages to current view by offset given
488 function set_view_ofs(jump)
489 local cur = get_view()
490 local all = get_tags()
492 if #all < 2 then
493 -- nothing to do if we have less then 2 tags
494 return
497 -- range check
498 if (jump < - #all) or (jump > #all) then
499 error ("view selector is out of range")
502 -- find the one that's selected index
503 local curi = nil
504 local i,v
505 for i,v in pairs (all) do
506 if v == cur then curi = i end
509 -- adjust by index
510 local newi = math.fmod(#all + curi + jump - 1, #all) + 1
511 if (newi < - #all) or (newi > #all) then
512 error ("error computng new view")
515 write ("/ctl", "view " .. all[newi])
518 -- ------------------------------------------------------------------------
519 -- toggle between last view and current view
520 function toggle_view()
521 local last = view_hist[#view_hist]
522 if last then
523 set_view(last)
527 -- ========================================================================
528 -- ACTION HANDLERS
529 -- ========================================================================
531 local action_handlers = {
532 man = function (act, args)
533 local xterm = get_conf("xterm") or "xterm"
534 local page = args
535 if (not page) or (not page:match("%S")) then
536 page = wmiidir .. "/wmii.3lua"
538 local cmd = xterm .. " -e man " .. page .. " &"
539 log (" executing: " .. cmd)
540 os.execute (cmd)
541 end,
543 quit = function ()
544 write ("/ctl", "quit")
545 end,
547 exec = function (act, args)
548 local what = args or "wmii"
549 log (" asking wmii to exec " .. tostring(what))
550 cleanup()
551 write ("/ctl", "exec " .. what)
552 end,
554 xlock = function (act)
555 local cmd = get_conf("xlock") or "xscreensaver-command --lock"
556 os.execute (cmd)
557 end,
559 wmiirc = function ()
560 if have_posix then
561 local wmiirc = find_wmiirc()
562 if wmiirc then
563 log (" executing: lua " .. wmiirc)
564 cleanup()
565 posix.exec (wmiirc)
566 posix.exec ("/bin/sh", "-c", "exec lua wmiirc")
567 posix.exec ("/usr/bin/lua", wmiirc)
569 else
570 log("sorry cannot restart; you don't have lua's posix library.")
572 end,
574 urgent = function ()
575 wmixp:write ("/client/sel/ctl", "Urgent toggle")
576 end,
578 --[[
579 rehash = function ()
580 -- TODO: consider storing list of executables around, and
581 -- this will then reinitialize that list
582 log (" TODO: rehash")
583 end,
585 status = function ()
586 -- TODO: this should eventually update something on the /rbar
587 log (" TODO: status")
588 end,
589 --]]
592 --[[
593 =pod
595 =item add_action_handler (action, fn)
597 Add an Alt-a action handler callback function, I<fn>, for the given action string I<action>.
599 =cut
600 --]]
601 function add_action_handler (action, fn)
603 if type(action) ~= "string" or type(fn) ~= "function" then
604 error ("expecting a string and a function")
607 if action_handlers[action] then
608 error ("action handler already exists for '" .. action .. "'")
611 action_handlers[action] = fn
614 --[[
615 =pod
617 =item remove_action_handler (action)
619 Remove an action handler callback function for the given action string I<action>.
621 =cut
622 --]]
623 function remove_action_handler (action)
625 action_handlers[action] = nil
628 -- ========================================================================
629 -- KEY HANDLERS
630 -- ========================================================================
632 function ke_fullscreen_toggle()
633 wmixp:write ("/client/sel/ctl", "Fullscreen toggle")
636 function ke_view_starting_with_letter (letter)
637 local i,v
639 -- find the view name in history in reverse order
640 for i=#view_hist,1,-1 do
641 v = view_hist[i]
642 if letter == v:sub(1,1) then
643 set_view(v)
644 return true
648 -- otherwise just pick the first view that matches
649 local all = get_tags()
650 for i,v in pairs(all) do
651 if letter == v:sub(1,1) then
652 set_view_index (i)
653 return true
657 return false
660 function ke_handle_action()
661 local actions = { }
662 local seen = {}
664 local n
665 for n in action_hist:walk_reverse() do
666 if not seen[n] then
667 actions[#actions+1] = n
668 seen[n] = 1
672 local v
673 for n,v in pairs(action_handlers) do
674 if not seen[n] then
675 actions[#actions+1] = n
676 seen[n] = 1
680 local text = menu(actions, "action:")
681 if text then
682 log ("Action: " .. text)
683 local act = text
684 local args = nil
685 local si = text:find("%s")
686 if si then
687 act,args = string.match(text .. " ", "(%w+)%s(.+)")
689 if act then
690 local fn = action_handlers[act]
691 if fn then
692 action_hist:add (act)
693 local r, err = pcall (fn, act, args)
694 if not r then
695 log ("WARNING: " .. tostring(err))
703 local key_handlers = {
704 ["*"] = function (key)
705 log ("*: " .. key)
706 end,
708 -- execution and actions
709 ["Mod1-Return"] = function (key)
710 local xterm = get_conf("xterm") or "xterm"
711 log (" executing: " .. xterm)
712 os.execute (xterm .. " &")
713 end,
714 ["Mod1-Shift-Return"] = function (key)
715 local tag = tag_menu()
716 if tag then
717 local xterm = get_conf("xterm") or "xterm"
718 log (" executing: " .. xterm .. " on: " .. tag)
719 next_client_goes_to_tag = tag
720 os.execute (xterm .. " &")
722 end,
723 ["Mod1-a"] = function (key)
724 ke_handle_action()
725 end,
726 ["Mod1-p"] = function (key)
727 local prog = prog_menu()
728 if prog then
729 prog_hist:add(prog:match("(%w+)"))
730 log (" executing: " .. prog)
731 os.execute (prog .. " &")
733 end,
734 ["Mod1-Shift-p"] = function (key)
735 local tag = tag_menu()
736 if tag then
737 local prog = prog_menu()
738 if prog then
739 log (" executing: " .. prog .. " on: " .. tag)
740 next_client_goes_to_tag = tag
741 os.execute (prog .. " &")
744 end,
745 ["Mod1-Shift-c"] = function (key)
746 write ("/client/sel/ctl", "kill")
747 end,
749 -- HJKL active selection
750 ["Mod1-h"] = function (key)
751 write ("/tag/sel/ctl", "select left")
752 end,
753 ["Mod1-l"] = function (key)
754 write ("/tag/sel/ctl", "select right")
755 end,
756 ["Mod1-j"] = function (key)
757 write ("/tag/sel/ctl", "select down")
758 end,
759 ["Mod1-k"] = function (key)
760 write ("/tag/sel/ctl", "select up")
761 end,
763 -- HJKL movement
764 ["Mod1-Shift-h"] = function (key)
765 write ("/tag/sel/ctl", "send sel left")
766 end,
767 ["Mod1-Shift-l"] = function (key)
768 write ("/tag/sel/ctl", "send sel right")
769 end,
770 ["Mod1-Shift-j"] = function (key)
771 write ("/tag/sel/ctl", "send sel down")
772 end,
773 ["Mod1-Shift-k"] = function (key)
774 write ("/tag/sel/ctl", "send sel up")
775 end,
777 -- floating vs tiled
778 ["Mod1-space"] = function (key)
779 write ("/tag/sel/ctl", "select toggle")
780 end,
781 ["Mod1-Shift-space"] = function (key)
782 write ("/tag/sel/ctl", "send sel toggle")
783 end,
785 -- work spaces (# and @ are wildcards for numbers and letters)
786 ["Mod4-#"] = function (key, num)
787 -- first attempt to find a view that starts with the number requested
788 local num_str = tostring(num)
789 if not ke_view_starting_with_letter (num_str) then
790 -- if we fail, then set it to the index requested
791 set_view_index (num)
793 end,
794 ["Mod4-Shift-#"] = function (key, num)
795 write ("/client/sel/tags", tostring(num))
796 end,
797 ["Mod4-@"] = function (key, letter)
798 ke_view_starting_with_letter (letter)
799 end,
800 ["Mod4-Shift-@"] = function (key, letter)
801 local all = get_tags()
802 local i,v
803 for i,v in pairs(all) do
804 if letter == v:sub(1,1) then
805 write ("/client/sel/tags", v)
806 break
809 end,
810 ["Mod1-comma"] = function (key)
811 set_view_ofs (-1)
812 end,
813 ["Mod1-period"] = function (key)
814 set_view_ofs (1)
815 end,
816 ["Mod1-r"] = function (key)
817 -- got to the last view
818 toggle_view()
819 end,
821 -- switching views and retagging
822 ["Mod1-t"] = function (key)
823 -- got to a view
824 local tag = tag_menu()
825 if tag then
826 set_view (tag)
828 end,
829 ["Mod1-Shift-t"] = function (key)
830 -- move selected client to a tag
831 local tag = tag_menu()
832 if tag then
833 write ("/client/sel/tags", tag)
835 end,
836 ["Mod1-Shift-r"] = function (key)
837 -- move selected client to a tag, and follow
838 local tag = tag_menu()
839 if tag then
840 write ("/client/sel/tags", tag)
841 set_view(tag)
843 end,
844 ["Mod1-Control-t"] = function (key)
845 log (" TODO: Mod1-Control-t: " .. key)
846 end,
848 -- column modes
849 ["Mod1-d"] = function (key)
850 write("/tag/sel/ctl", "colmode sel default")
851 end,
852 ["Mod1-s"] = function (key)
853 write("/tag/sel/ctl", "colmode sel stack")
854 end,
855 ["Mod1-m"] = function (key)
856 write("/tag/sel/ctl", "colmode sel max")
857 end,
858 ["Mod1-f"] = function (key)
859 ke_fullscreen_toggle()
860 end,
862 -- changing client flags
863 ["Shift-Mod1-f"] = function (key)
864 log ("setting flags")
866 local cli = get_client ()
868 local flags = { "suspend", "raw" }
869 local current_flags = cli:flags_string()
871 local what = menu(flags, "current flags: " .. current_flags .. " toggle:")
873 cli:toggle(what)
874 end,
875 ["Mod4-space"] = function (key)
876 local cli = get_client ()
877 cli:toggle("raw")
878 end,
881 --[[
882 =pod
884 =item add_key_handler (key, fn)
886 Add a keypress handler callback function, I<fn>, for the given key sequence I<key>.
888 =cut
889 --]]
890 function add_key_handler (key, fn)
892 if type(key) ~= "string" or type(fn) ~= "function" then
893 error ("expecting a string and a function")
896 if key_handlers[key] then
897 -- TODO: we may wish to allow multiple handlers for one keypress
898 error ("key handler already exists for '" .. key .. "'")
901 key_handlers[key] = fn
904 --[[
905 =pod
907 =item remove_key_handler (key)
909 Remove an key handler callback function for the given key I<key>.
911 Returns the handler callback function.
913 =cut
914 --]]
915 function remove_key_handler (key)
917 local fn = key_handlers[key]
918 key_handlers[key] = nil
919 return fn
922 --[[
923 =pod
925 =item remap_key_handler (old_key, new_key)
927 Remove a key handler callback function from the given key I<old_key>,
928 and assign it to a new key I<new_key>.
930 =cut
931 --]]
932 function remap_key_handler (old_key, new_key)
934 local fn = remove_key_handler(old_key)
936 return add_key_handler (new_key, fn)
940 -- ------------------------------------------------------------------------
941 -- update the /keys wmii file with the list of all handlers
942 local alphabet="abcdefghijklmnopqrstuvwxyz"
943 function update_active_keys ()
944 local t = {}
945 local x, y
946 for x,y in pairs(key_handlers) do
947 if x:find("%w") then
948 local i = x:find("#$")
949 if i then
950 local j
951 for j=0,9 do
952 t[#t + 1] = x:sub(1,i-1) .. j
954 else
955 i = x:find("@$")
956 if i then
957 local j
958 for j=1,alphabet:len() do
959 local a = alphabet:sub(j,j)
960 t[#t + 1] = x:sub(1,i-1) .. a
962 else
963 t[#t + 1] = tostring(x)
968 local all_keys = table.concat(t, "\n")
969 --log ("setting /keys to...\n" .. all_keys .. "\n");
970 write ("/keys", all_keys)
973 -- ------------------------------------------------------------------------
974 -- update the /lbar wmii file with the current tags
975 function update_displayed_tags ()
976 -- colours for /lbar
977 local fc = get_ctl("focuscolors") or ""
978 local nc = get_ctl("normcolors") or ""
980 -- build up a table of existing tags in the /lbar
981 local old = {}
982 local s
983 for s in wmixp:idir ("/lbar") do
984 old[s.name] = 1
987 -- for all actual tags in use create any entries in /lbar we don't have
988 -- clear the old table entries if we have them
989 local cur = get_view()
990 local all = get_tags()
991 local i,v
992 for i,v in pairs(all) do
993 local color = nc
994 if cur == v then
995 color = fc
997 if not old[v] then
998 create ("/lbar/" .. v, color .. " " .. v)
1000 write ("/lbar/" .. v, color .. " " .. v)
1001 old[v] = nil
1004 -- anything left in the old table should be removed now
1005 for i,v in pairs(old) do
1006 if v then
1007 remove("/lbar/"..i)
1012 -- ========================================================================
1013 -- EVENT HANDLERS
1014 -- ========================================================================
1016 local widget_ev_handlers = {
1019 --[[
1020 =pod
1022 =item _handle_widget_event (ev, arg)
1024 Top-level event handler for redispatching events to widgets. This event
1025 handler is added for any widget event that currently has a widget registered
1026 for it.
1028 Valid widget events are currently
1030 RightBarMouseDown <buttonnumber> <widgetname>
1031 RightBarClick <buttonnumber> <widgetname>
1033 the "Click" event is sent on mouseup.
1035 The callbacks are given only the button number as their argument, to avoid the
1036 need to reparse.
1038 =cut
1039 --]]
1041 local function _handle_widget_event (ev, arg)
1043 log("_handle_widget_event: " .. tostring(ev) .. " - " .. tostring(arg))
1045 -- parse arg to strip out our widget name
1046 local number,wname = string.match(arg, "(%d+)%s+(.+)")
1048 -- check our dispatch table for that widget
1049 if not wname then
1050 log("Didn't find wname")
1051 return
1054 local wtable = widget_ev_handlers[wname]
1055 if not wtable then
1056 log("No widget cares about" .. wname)
1057 return
1060 local fn = wtable[ev] or wtable["*"]
1061 if fn then
1062 success, err = pcall( fn, ev, tonumber(number) )
1063 if not success then
1064 log("Callback had an error in _handle_widget_event: " .. tostring(err) )
1065 return nil
1067 else
1068 log("no function found for " .. ev)
1072 local ev_handlers = {
1073 ["*"] = function (ev, arg)
1074 log ("ev: " .. tostring(ev) .. " - " .. tostring(arg))
1075 end,
1077 RightBarClick = _handle_widget_event,
1079 -- process timer events
1080 ProcessTimerEvents = function (ev, arg)
1081 process_timers()
1082 end,
1084 -- exit if another wmiirc started up
1085 Start = function (ev, arg)
1086 if arg then
1087 if arg == "wmiirc" then
1088 -- backwards compatibility with bash version
1089 log (" exiting; pid=" .. tostring(myid))
1090 cleanup()
1091 os.exit (0)
1092 else
1093 -- ignore if it came from us
1094 local pid = string.match(arg, "wmiirc (%d+)")
1095 if pid then
1096 local pid = tonumber (pid)
1097 if not (pid == myid) then
1098 log (" exiting; pid=" .. tostring(myid))
1099 cleanup()
1100 os.exit (0)
1105 end,
1107 -- tag management
1108 CreateTag = function (ev, arg)
1109 local nc = get_ctl("normcolors") or ""
1110 create ("/lbar/" .. arg, nc .. " " .. arg)
1111 end,
1112 DestroyTag = function (ev, arg)
1113 remove ("/lbar/" .. arg)
1115 -- remove the tag from history
1116 local i,v
1117 for i=#view_hist,1,-1 do
1118 v = view_hist[i]
1119 if arg == v then
1120 table.remove(view_hist,i)
1123 end,
1125 FocusTag = function (ev, arg)
1126 local fc = get_ctl("focuscolors") or ""
1127 create ("/lbar/" .. arg, fc .. " " .. arg)
1128 write ("/lbar/" .. arg, fc .. " " .. arg)
1129 end,
1130 UnfocusTag = function (ev, arg)
1131 local nc = get_ctl("normcolors") or ""
1132 create ("/lbar/" .. arg, nc .. " " .. arg)
1133 write ("/lbar/" .. arg, nc .. " " .. arg)
1135 -- don't duplicate the last entry
1136 if not (arg == view_hist[#view_hist]) then
1137 view_hist[#view_hist+1] = arg
1139 -- limit to view_hist_max
1140 if #view_hist > view_hist_max then
1141 table.remove(view_hist, 1)
1144 end,
1146 -- key event handling
1147 Key = function (ev, arg)
1148 log ("Key: " .. arg)
1149 local magic = nil
1150 -- can we find an exact match?
1151 local fn = key_handlers[arg]
1152 if not fn then
1153 local key = arg:gsub("-%d$", "-#")
1154 -- can we find a match with a # wild card for the number
1155 fn = key_handlers[key]
1156 if fn then
1157 -- convert the trailing number to a number
1158 magic = tonumber(arg:match("-(%d)$"))
1161 if not fn then
1162 local key = arg:gsub("-%a$", "-@")
1163 -- can we find a match with a @ wild card for a letter
1164 fn = key_handlers[key]
1165 if fn then
1166 -- split off the trailing letter
1167 magic = arg:match("-(%a)$")
1170 if not fn then
1171 -- everything else failed, try default match
1172 fn = key_handlers["*"]
1174 if fn then
1175 local r, err = pcall (fn, arg, magic)
1176 if not r then
1177 log ("WARNING: " .. tostring(err))
1180 end,
1182 -- mouse handling on the lbar
1183 LeftBarClick = function (ev, arg)
1184 local button,tag = string.match(arg, "(%w+)%s+(%S+)")
1185 set_view (tag)
1186 end,
1188 -- focus updates
1189 ClientFocus = function (ev, arg)
1190 log ("ClientFocus: " .. arg)
1191 client_focused (arg)
1192 end,
1193 ColumnFocus = function (ev, arg)
1194 log ("ColumnFocus: " .. arg)
1195 end,
1197 -- client handling
1198 CreateClient = function (ev, arg)
1199 if next_client_goes_to_tag then
1200 local tag = next_client_goes_to_tag
1201 local cli = arg
1202 next_client_goes_to_tag = nil
1203 write ("/client/" .. cli .. "/tags", tag)
1204 set_view(tag)
1206 client_created (arg)
1207 end,
1208 DestroyClient = function (ev, arg)
1209 client_destoryed (arg)
1210 end,
1212 -- force the next window tags
1213 NextWindowTags = function (ev, arg)
1214 if type(arg) == 'string' then
1215 log (" forcing next client to tags: " .. arg)
1216 next_client_goes_to_tag = arg
1218 end,
1220 -- urgent tag?
1221 UrgentTag = function (ev, arg)
1222 log ("UrgentTag: " .. arg)
1223 -- wmiir xwrite "/lbar/$@" "*$@"
1224 end,
1225 NotUrgentTag = function (ev, arg)
1226 log ("NotUrgentTag: " .. arg)
1227 -- wmiir xwrite "/lbar/$@" "$@"
1232 --[[
1233 =pod
1235 =item add_widget_event_handler (wname, ev, fn)
1237 Add an event handler callback for the I<ev> event on the widget named I<wname>
1239 =cut
1240 --]]
1242 function add_widget_event_handler (wname, ev, fn)
1243 if type(wname) ~= "string" or type(ev) ~= "string" or type(fn) ~= "function" then
1244 error ("expecting string for widget name, string for event name and a function callback")
1247 -- Make sure the widget event handler is present
1248 if not ev_handlers[ev] then
1249 ev_handlers[ev] = _handle_widget_event
1252 if not widget_ev_handlers[wname] then
1253 widget_ev_handlers[wname] = { }
1256 if widget_ev_handlers[wname][ev] then
1257 -- TODO: we may wish to allow multiple handlers for one event
1258 error ("event handler already exists on widget '" .. wname .. "' for '" .. ev .. "'")
1261 widget_ev_handlers[wname][ev] = fn
1264 --[[
1265 =pod
1267 =item remove_widget_event_handler (wname, ev)
1269 Remove an event handler callback function for the I<ev> on the widget named I<wname>.
1271 =cut
1272 --]]
1273 function remove_event_handler (wname, ev)
1275 if not widget_ev_handlers[wname] then
1276 return
1279 widget_ev_handlers[wname][ev] = nil
1282 --[[
1283 =pod
1285 =item add_event_handler (ev, fn)
1287 Add an event handler callback function, I<fn>, for the given event I<ev>.
1289 =cut
1290 --]]
1291 -- TODO: Need to allow registering widgets for RightBar* events. Should probably be done with its own event table, though
1292 function add_event_handler (ev, fn)
1293 if type(ev) ~= "string" or type(fn) ~= "function" then
1294 error ("expecting a string and a function")
1297 if ev_handlers[ev] then
1298 -- TODO: we may wish to allow multiple handlers for one event
1299 error ("event handler already exists for '" .. ev .. "'")
1303 ev_handlers[ev] = fn
1306 --[[
1307 =pod
1309 =item remove_event_handler (ev)
1311 Remove an event handler callback function for the given event I<ev>.
1313 =cut
1314 --]]
1315 function remove_event_handler (ev)
1317 ev_handlers[ev] = nil
1321 -- ========================================================================
1322 -- MAIN INTERFACE FUNCTIONS
1323 -- ========================================================================
1325 local config = {
1326 xterm = 'x-terminal-emulator',
1327 xlock = "xscreensaver-command --lock",
1328 debug = false,
1331 -- ------------------------------------------------------------------------
1332 -- write configuration to /ctl wmii file
1333 -- wmii.set_ctl({ "var" = "val", ...})
1334 -- wmii.set_ctl("var, "val")
1335 function set_ctl (first,second)
1336 if type(first) == "table" and second == nil then
1337 local x, y
1338 for x, y in pairs(first) do
1339 write ("/ctl", x .. " " .. y)
1342 elseif type(first) == "string" and type(second) == "string" then
1343 write ("/ctl", first .. " " .. second)
1345 else
1346 error ("expecting a table or two string arguments")
1350 -- ------------------------------------------------------------------------
1351 -- read a value from /ctl wmii file
1352 -- table = wmii.get_ctl()
1353 -- value = wmii.get_ctl("variable"
1354 function get_ctl (name)
1355 local s
1356 local t = {}
1357 for s in iread("/ctl") do
1358 local var,val = s:match("(%w+)%s+(.+)")
1359 if var == name then
1360 return val
1362 t[var] = val
1364 if not name then
1365 return t
1367 return nil
1370 -- ------------------------------------------------------------------------
1371 -- set an internal wmiirc.lua variable
1372 -- wmii.set_conf({ "var" = "val", ...})
1373 -- wmii.set_conf("var, "val")
1374 function set_conf (first,second)
1375 if type(first) == "table" and second == nil then
1376 local x, y
1377 for x, y in pairs(first) do
1378 config[x] = y
1381 elseif type(first) == "string"
1382 and (type(second) == "string"
1383 or type(second) == "number") then
1384 config[first] = second
1386 else
1387 error ("expecting a table, or string and string/number as arguments")
1391 -- ------------------------------------------------------------------------
1392 -- read an internal wmiirc.lua variable
1393 function get_conf (name)
1394 if name then
1395 return config[name]
1397 return config
1400 -- ========================================================================
1401 -- THE EVENT LOOP
1402 -- ========================================================================
1404 -- the event loop instance
1405 local el = eventloop.new()
1407 -- add the core event handler for events
1408 el:add_exec (wmiir .. " read /event",
1409 function (line)
1410 local line = line or "nil"
1412 -- try to split off the argument(s)
1413 local ev,arg = string.match(line, "(%S+)%s+(.+)")
1414 if not ev then
1415 ev = line
1418 -- now locate the handler function and call it
1419 local fn = ev_handlers[ev] or ev_handlers["*"]
1420 if fn then
1421 local r, err = pcall (fn, ev, arg)
1422 if not r then
1423 log ("WARNING: " .. tostring(err))
1426 end)
1428 -- ------------------------------------------------------------------------
1429 -- run the event loop and process events, this function does not exit
1430 function run_event_loop ()
1431 -- stop any other instance of wmiirc
1432 wmixp:write ("/event", "Start wmiirc " .. tostring(myid))
1434 log("wmii: updating lbar")
1436 update_displayed_tags ()
1438 log("wmii: updating rbar")
1440 update_displayed_widgets ()
1442 log("wmii: updating active keys")
1444 update_active_keys ()
1446 log("wmii: starting event loop")
1447 while true do
1448 local sleep_for = process_timers()
1449 el:run_loop(sleep_for)
1453 -- ========================================================================
1454 -- PLUGINS API
1455 -- ========================================================================
1457 api_version = 0.1 -- the API version we export
1459 plugins = {} -- all plugins that were loaded
1461 -- ------------------------------------------------------------------------
1462 -- plugin loader which also verifies the version of the api the plugin needs
1464 -- here is what it does
1465 -- - does a manual locate on the file using package.path
1466 -- - reads in the file w/o using the lua interpreter
1467 -- - locates api_version=X.Y string
1468 -- - makes sure that api_version requested can be satisfied
1469 -- - if the plugins is available it will set variables passed in
1470 -- - it then loads the plugin
1472 -- TODO: currently the api_version must be in an X.Y format, but we may want
1473 -- to expend this so plugins can say they want '0.1 | 1.3 | 2.0' etc
1475 function load_plugin(name, vars)
1476 local backup_path = package.path or "./?.lua"
1478 log ("loading " .. name)
1480 -- this is the version we want to find
1481 local api_major, api_minor = tostring(api_version):match("(%d+)%.0*(%d+)")
1482 if (not api_major) or (not api_minor) then
1483 log ("WARNING: could not parse api_version in core/wmii.lua")
1484 return nil
1487 -- first find the plugin file
1488 local s, path_match, full_name, file
1489 for s in string.gmatch(plugin_path, "[^;]+") do
1490 -- try to locate the files locally
1491 local fn = s:gsub("%?", name)
1492 file = io.open(fn, "r")
1493 if file then
1494 path_match = s
1495 full_name = fn
1496 break
1500 -- read it in
1501 local txt
1502 if file then
1503 txt = file:read("*all")
1504 file:close()
1507 if not txt then
1508 log ("WARNING: could not load plugin '" .. name .. "'")
1509 return nil
1512 -- find the api_version line
1513 local line, plugin_version
1514 for line in string.gmatch(txt, "%s*api_version%s*=%s*%d+%.%d+%s*") do
1515 plugin_version = line:match("api_version%s*=%s*(%d+%.%d+)%s*")
1516 if plugin_version then
1517 break
1521 if not plugin_version then
1522 log ("WARNING: could not find api_version string in plugin '" .. name .. "'")
1523 return nil
1526 -- decompose the version string
1527 local plugin_major, plugin_minor = plugin_version:match("(%d+)%.0*(%d+)")
1528 if (not plugin_major) or (not plugin_minor) then
1529 log ("WARNING: could not parse api_version for '" .. name .. "' plugin")
1530 return nil
1533 -- make a version test
1534 if plugin_major ~= api_major then
1535 log ("WARNING: " .. name .. " plugin major version missmatch, is " .. plugin_version
1536 .. " (api " .. tonumber(api_version) .. ")")
1537 return nil
1540 if plugin_minor > api_minor then
1541 log ("WARNING: '" .. name .. "' plugin minor version missmatch, is " .. plugin_version
1542 .. " (api " .. tonumber(api_version) .. ")")
1543 return nil
1546 -- the configuration parameters before loading
1547 if type(vars) == "table" then
1548 local var, val
1549 for var,val in pairs(vars) do
1550 local success = pcall (set_conf, name .. "." .. var, val)
1551 if not success then
1552 log ("WARNING: bad variable {" .. tostring(var) .. ", " .. tostring(val) .. "} "
1553 .. "given; loading '" .. name .. "' plugin failed.")
1554 return nil
1559 -- actually load the module, but use only the path where we though it should be
1560 package.path = path_match
1561 local success,what = pcall (require, name)
1562 package.path = backup_path
1563 if not success then
1564 log ("WARNING: failed to load '" .. name .. "' plugin")
1565 log (" - path: " .. tostring(path_match))
1566 log (" - file: " .. tostring(full_name))
1567 log (" - plugin's api_version: " .. tostring(plugin_version))
1568 log (" - reason: " .. tostring(what))
1569 return nil
1572 -- success
1573 log ("OK, plugin " .. name .. " loaded, requested api v" .. plugin_version)
1574 plugins[name] = what
1575 return what
1578 -- ------------------------------------------------------------------------
1579 -- widget template
1580 widget = {}
1581 widgets = {}
1583 -- ------------------------------------------------------------------------
1584 -- create a widget object and add it to the wmii /rbar
1586 -- examples:
1587 -- widget = wmii.widget:new ("999_clock")
1588 -- widget = wmii.widget:new ("999_clock", clock_event_handler)
1589 function widget:new (name, fn)
1590 local o = {}
1592 if type(name) == "string" then
1593 o.name = name
1594 if type(fn) == "function" then
1595 o.fn = fn
1597 else
1598 error ("expected name followed by an optional function as arguments")
1601 setmetatable (o,self)
1602 self.__index = self
1603 self.__gc = function (o) o:hide() end
1605 widgets[name] = o
1607 o:show()
1608 return o
1611 -- ------------------------------------------------------------------------
1612 -- stop and destroy the timer
1613 function widget:delete ()
1614 widgets[self.name] = nil
1615 self:hide()
1618 -- ------------------------------------------------------------------------
1619 -- displays or updates the widget text
1621 -- examples:
1622 -- w:show("foo")
1623 -- w:show("foo", "#888888 #222222 #333333")
1624 -- w:show("foo", cell_fg .. " " .. cell_bg .. " " .. border)
1626 function widget:show (txt, colors)
1627 local colors = colors or get_ctl("normcolors") or ""
1628 local txt = txt or self.txt or ""
1629 local towrite = txt
1630 if colors then
1631 towrite = colors .. " " .. towrite
1633 if not self.txt then
1634 create ("/rbar/" .. self.name, towrite)
1635 else
1636 write ("/rbar/" .. self.name, towrite)
1638 self.txt = txt
1641 -- ------------------------------------------------------------------------
1642 -- hides a widget and removes it from the bar
1643 function widget:hide ()
1644 if self.txt then
1645 remove ("/lbar/" .. self.name)
1646 self.txt = nil
1650 --[[
1651 =pod
1653 =item widget:add_event_handler (ev, fn)
1655 Add an event handler callback for this widget, using I<fn> for event I<ev>
1657 =cut
1658 --]]
1660 function widget:add_event_handler (ev, fn)
1661 add_widget_event_handler( self.name, ev, fn)
1665 -- ------------------------------------------------------------------------
1666 -- remove all /rbar entries that we don't have widget objects for
1667 function update_displayed_widgets ()
1668 -- colours for /rbar
1669 local nc = get_ctl("normcolors") or ""
1671 -- build up a table of existing tags in the /lbar
1672 local old = {}
1673 local s
1674 for s in wmixp:idir ("/rbar") do
1675 old[s.name] = 1
1678 -- for all actual widgets in use we want to remove them from the old list
1679 local i,v
1680 for i,v in pairs(widgets) do
1681 old[v.name] = nil
1684 -- anything left in the old table should be removed now
1685 for i,v in pairs(old) do
1686 if v then
1687 remove("/rbar/"..i)
1692 -- ------------------------------------------------------------------------
1693 -- fork and exec a program; the callback function is called for each line
1694 -- read from the stdout of that program; the return is the fd that can be
1695 -- passed to kill_exec to terminate the program.
1696 function add_exec (command, callback)
1697 return el:add_exec (command, callback)
1700 -- ------------------------------------------------------------------------
1701 -- terminates a program spawned off by add_exec()
1702 function kill_exec (fd)
1703 return el:kill_exec (fd)
1706 -- ------------------------------------------------------------------------
1707 -- timer template
1708 timer = {}
1709 local timers = {}
1711 -- ------------------------------------------------------------------------
1712 -- create a timer object and add it to the event loop
1714 -- examples:
1715 -- timer:new (my_timer_fn)
1716 -- timer:new (my_timer_fn, 15)
1717 function timer:new (fn, seconds)
1718 local o = {}
1720 if type(fn) == "function" then
1721 o.fn = fn
1722 else
1723 error ("expected function followed by an optional number as arguments")
1726 setmetatable (o,self)
1727 self.__index = self
1728 self.__gc = function (o) o:stop() end
1730 -- add the timer
1731 timers[#timers+1] = o
1733 if seconds then
1734 o:resched(seconds)
1736 return o
1739 -- ------------------------------------------------------------------------
1740 -- stop and destroy the timer
1741 function timer:delete ()
1742 self:stop()
1743 local i,t
1744 for i,t in pairs(timers) do
1745 if t == self then
1746 table.remove (timers,i)
1747 return
1752 -- ------------------------------------------------------------------------
1753 -- run the timer given new interval
1754 function timer:resched (seconds)
1755 local seconds = seconds or self.interval
1756 if not (type(seconds) == "number") then
1757 error ("timer:resched expected number as argument")
1760 local now = tonumber(os.date("%s"))
1762 self.interval = seconds
1763 self.next_time = now + seconds
1765 -- resort the timer list
1766 table.sort (timers, timer.is_less_then)
1769 -- helper for sorting timers
1770 function timer:is_less_then(another)
1771 if not self.next_time then
1772 return false -- another is smaller, nil means infinity
1774 elseif not another.next_time then
1775 return true -- self is smaller, nil means infinity
1777 elseif self.next_time < another.next_time then
1778 return true -- self is smaller than another
1781 return false -- another is smaller then self
1784 -- ------------------------------------------------------------------------
1785 -- stop the timer
1786 function timer:stop ()
1787 self.next_time = nil
1789 -- resort the timer list
1790 table.sort (timers, timer.is_less_then)
1793 -- ------------------------------------------------------------------------
1794 -- figure out how long before the next event
1795 function time_before_next_timer_event()
1796 local tmr = timers[1]
1797 if tmr and tmr.next_time then
1798 local now = tonumber(os.date("%s"))
1799 local seconds = tmr.next_time - now
1800 if seconds > 0 then
1801 return seconds
1804 return 0 -- sleep for ever
1807 -- ------------------------------------------------------------------------
1808 -- handle outstanding events
1809 function process_timers ()
1810 local now = tonumber(os.date("%s"))
1811 local torun = {}
1812 local i,tmr
1814 for i,tmr in pairs (timers) do
1815 if not tmr then
1816 -- prune out removed timers
1817 table.remove(timers,i)
1818 break
1820 elseif not tmr.next_time then
1821 -- break out once we find a timer that is stopped
1822 break
1824 elseif tmr.next_time > now then
1825 -- break out once we get to the future
1826 break
1829 -- this one is good to go
1830 torun[#torun+1] = tmr
1833 for i,tmr in pairs (torun) do
1834 tmr:stop()
1835 local status,new_interval = pcall (tmr.fn, tmr)
1836 if status then
1837 new_interval = new_interval or self.interval
1838 if new_interval and (new_interval ~= -1) then
1839 tmr:resched(new_interval)
1841 else
1842 log ("ERROR: " .. tostring(new_interval))
1846 local sleep_for = time_before_next_timer_event()
1847 return sleep_for
1850 -- ------------------------------------------------------------------------
1851 -- cleanup everything in preparation for exit() or exec()
1852 function cleanup ()
1854 local i,v,tmr,p
1856 log ("wmii: stopping timer events")
1858 for i,tmr in pairs (timers) do
1859 pcall (tmr.delete, tmr)
1861 timers = {}
1863 log ("wmii: terminating eventloop")
1865 pcall(el.kill_all,el)
1867 log ("wmii: disposing of widgets")
1869 -- dispose of all widgets
1870 for i,v in pairs(widgets) do
1871 pcall(v.delete,v)
1873 timers = {}
1875 -- FIXME: it doesn't seem to do what I want
1876 --[[
1877 log ("wmii: releasing plugins")
1879 for i,p in pairs(plugins) do
1880 if p.cleanup then
1881 pcall (p.cleanup, p)
1884 plugins = {}
1885 --]]
1887 log ("wmii: dormant")
1890 -- ========================================================================
1891 -- CLIENT HANDLING
1892 -- ========================================================================
1894 --[[
1895 -- Notes on client tracking
1897 -- When a client is created wmii sends us a CreateClient message, and
1898 -- we in turn create a 'client' object and store it in the 'clients'
1899 -- table indexed by the client's ID.
1901 -- Each client object stores the following:
1902 -- .xid - the X client ID
1903 -- .pid - the process ID
1904 -- .prog - program object representing the process
1906 -- The client and program objects track the following modes for each program:
1908 -- raw mode:
1909 -- - for each client window
1910 -- - Mod4-space toggles the state between normal and raw
1911 -- - Mod1-f raw also toggles the state
1912 -- - in raw mode all input goes to the client, except for Mod4-space
1913 -- - a focused client with raw mode enabled is put into raw mode
1915 -- suspend mode:
1916 -- - for each program
1917 -- - Mod1-f suspend toggles the state for current client's program
1918 -- - a focused client, whose program was previous suspended is resumed
1919 -- - an unfocused client, with suspend enabled, will be suspended
1920 -- - suspend/resume is done by sending the STOP/CONT signals to the PID
1921 --]]
1923 function xid_to_pid (xid)
1924 local cmd = "xprop -id " .. tostring(xid) .. " _NET_WM_PID"
1925 local file = io.popen (cmd)
1926 local out = file:read("*a")
1927 file:close()
1928 local pid = out:match("^_NET_WM_PID.*%s+=%s+(%d+)%s+$")
1929 return tonumber(pid)
1932 local focused_xid = nil
1933 local clients = {} -- table of client objects indexed by xid
1934 local programs = {} -- table of program objects indexed by pid
1935 local mode_widget = widget:new ("999_client_mode")
1937 -- make programs table have weak values
1938 -- programs go away as soon as no clients point to it
1939 local programs_mt = {}
1940 setmetatable(programs, programs_mt)
1941 programs_mt.__mode = 'v'
1943 -- program class
1944 program = {}
1945 function program:new (pid)
1946 -- make an object
1947 local o = {}
1948 setmetatable (o,self)
1949 self.__index = self
1950 self.__gc = function (old) old:cont() end
1951 -- initialize the new object
1952 o.pid = pid
1953 -- suspend mode
1954 o.suspend = {}
1955 o.suspend.toggle = function (prog)
1956 prog.suspend.enabled = not prog.suspend.enabled
1958 o.suspend.enabled = false -- if true, defocusing suspends (SIGSTOP)
1959 o.suspend.active = true -- if true, focusing resumes (SIGCONT)
1960 return o
1963 function program:stop ()
1964 if not self.suspend.active then
1965 local cmd = "kill -STOP " .. tostring(self.pid)
1966 log (" executing: " .. cmd)
1967 os.execute (cmd)
1968 self.suspend.active = true
1972 function program:cont ()
1973 if self.suspend.active then
1974 local cmd = "kill -CONT " .. tostring(self.pid)
1975 log (" executing: " .. cmd)
1976 os.execute (cmd)
1977 self.suspend.active = false
1981 function get_program (pid)
1982 local prog = programs[pid]
1983 if not prog then
1984 prog = program:new (pid)
1985 programs[pid] = prog
1987 return prog
1990 -- client class
1991 client = {}
1992 function client:new (xid)
1993 -- make an object
1994 local o = {}
1995 setmetatable (o,self)
1996 self.__index = function (t,k)
1997 if k == 'suspend' then -- suspend mode is tracked per program
1998 return t.prog.suspend
2000 return self[k]
2002 self.__gc = function (old) old.prog=nil end
2003 -- initialize the new object
2004 o.xid = xid
2005 o.pid = xid_to_pid(xid)
2006 o.prog = get_program (o.pid)
2007 -- raw mode
2008 o.raw = {}
2009 o.raw.toggle = function (cli)
2010 cli.raw.enabled = not cli.raw.enabled
2011 cli:set_raw_mode()
2013 o.raw.enabled = false -- if true, raw mode enabled when client is focused
2014 return o
2017 function client:stop ()
2018 if self.suspend.enabled then
2019 self.prog:stop()
2023 function client:cont ()
2024 self.prog:cont()
2027 function client:set_raw_mode()
2028 if not self or not self.raw.enabled then -- normal mode
2029 update_active_keys ()
2030 else -- raw mode
2031 write ("/keys", "Mod4-space")
2035 function client:toggle(what)
2036 if what and self[what] then
2037 local ctl = self[what]
2039 ctl.toggle (self)
2041 log ("xid=" .. tostring (xid)
2042 .. " pid=" .. tostring (self.pid) .. " (" .. tostring (self.prog.pid) .. ")"
2043 .. " what=" .. tostring (what)
2044 .. " enabled=" .. tostring(ctl["enabled"]))
2046 mode_widget:show (self:flags_string())
2049 function client:flags_string()
2050 local ret = ''
2051 if self.suspend.enabled then ret = ret .. "s" else ret = ret .. "-" end
2052 if self.raw.enabled then ret = ret .. "r" else ret = ret .. "-" end
2053 return ret
2056 function get_client (xid)
2057 local xid = xid or wmixp:read("/client/sel/ctl")
2058 local cli = clients[xid]
2059 if not cli then
2060 cli = client:new (xid)
2061 clients[xid] = cli
2063 return cli
2066 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
2067 function client_created (xid)
2068 log ("-client_created " .. tostring(xid))
2069 return get_client(xid)
2072 function client_destoryed (xid)
2073 log ("-client_destoryed " .. tostring(xid))
2074 if clients[xid] then
2075 local cli = clients[xid]
2076 clients[xid] = nil
2077 log (" del pid: " .. tostring(cli.pid))
2078 cli:cont()
2082 function client_focused (xid)
2083 log ("-client_focused " .. tostring(xid))
2084 -- do nothing if the same xid
2085 if focused_xid == xid then
2086 return clients[xid]
2089 local old = clients[focused_xid]
2090 local new = get_client(xid)
2092 -- handle raw mode switch
2093 if not old or ( old and new and old.raw.enabled ~= new.raw.enabled ) then
2094 new:set_raw_mode()
2097 -- do nothing if the same pid
2098 if old and new and old.pid == new.pid then
2099 mode_widget:show (new:flags_string())
2100 return clients[xid]
2103 if old then
2104 --[[
2105 log (" old pid: " .. tostring(old.pid)
2106 .. " xid: " .. tostring(old.xid)
2107 .. " flags: " .. old:flags_string())
2108 ]]--
2109 old:stop()
2112 if new then
2113 --[[
2114 log (" new pid: " .. tostring(new.pid)
2115 .. " xid: " .. tostring(new.xid)
2116 .. " flags: " .. new:flags_string())
2117 ]]--
2118 new:cont()
2121 mode_widget:show (new:flags_string())
2122 focused_xid = xid
2123 return new
2127 -- ========================================================================
2128 -- DOCUMENTATION
2129 -- ========================================================================
2131 --[[
2132 =pod
2134 =back
2136 =head1 ENVIRONMENT
2138 =over 4
2140 =item WMII_ADDRESS
2142 Used to determine location of wmii's listen socket.
2144 =back
2146 =head1 SEE ALSO
2148 L<wmii(1)>, L<lua(1)>
2150 =head1 AUTHOR
2152 Bart Trojanowski B<< <bart@jukie.net> >>
2154 =head1 COPYRIGHT AND LICENSE
2156 Copyright (c) 2007, Bart Trojanowski <bart@jukie.net>
2158 This is free software. You may redistribute copies of it under the terms of
2159 the GNU General Public License L<http://www.gnu.org/licenses/gpl.html>. There
2160 is NO WARRANTY, to the extent permitted by law.
2162 =cut
2163 --]]